public LLinkedList <LTerm> GetResultListFrom(LLinkedListNode <LTerm> node)
{
LLinkedList <LTerm> resultList = null;
//在产生式集合中寻找与该Term匹配的产生式（相同的符号和参数个数）
List <LRule> matchingProductions = m_listProductionGroup.FindAll((rule) =>
rule.Predecessor.Symbol.Equals(node.Value.Symbol) /*****符号相同****/ &&
rule.Predecessor.Params.Count == node.Value.Params.Count /*****参数个数相同*****/
);
if (matchingProductions.Count > 0) //有匹配的产生式
{
float[] paramsArray = node.Value.GetParamsArrayWithFloat(); //获取参数
for (int i = 0; i < matchingProductions.Count; i++)
{
resultList = matchingProductions[i].GetResultList(node, paramsArray); //获取结果链表
if (resultList != null) //当返回NULL则说明该产生式的条件不符合；返回链表则说明该产生式可行
{
break;
}
}
}
return(resultList);
}
/// <summary>
/// 采用非多线程的方式迭代
/// </summary>
private void ReplaceFinalList()
{
LLinkedListNode <LTerm> node = m_listFinal.First; //从头节点开始
LLinkedListNode <LTerm> head = m_listFinal.First; //头节点
LLinkedList <LTerm> FinalList = new LLinkedList <LTerm>();
do
{
LLinkedListNode <LTerm> NodeClone = new LLinkedListNode <LTerm>(node.Value); //防止替换后原先的Node出现错误
FinalList.Add(NodeClone);
if (node.Value != null)
{
LLinkedList <LTerm> resultList = GetResultListFrom(node);
if (resultList != null)
{
FinalList.Replace(NodeClone, resultList);
}
}
node = node.Next;
} while (node != head);
m_listFinal = FinalList;
}
/// <summary>
/// 寻找匹配的括号
/// </summary>
/// <param name="node">从该节点开始寻找</param>
/// <param name="strBracket">待匹配的括号</param>
/// <returns></returns>
private LLinkedListNode <LTerm> FindMatchingBracket(LLinkedListNode <LTerm> node, string strBracket)
{
LLinkedListNode <LTerm> headNode = Belong.FinalList.First;
//Scene.GetInstance().TreeModel.RuleData.FinalList.First; //头节点
int iBalance = 0; //用于标识是否平衡，当出现[时，iBalance加一，当出现]时，iBalance减一，当iBalance等于0时，左右括号个数相等
if (strBracket.Equals("]"))
{
iBalance = -1;
LLinkedListNode <LTerm> currentNode = node;
do
{
if (currentNode.Value.Symbol.Equals("["))
{
iBalance += 1;
}
else if (currentNode.Value.Symbol.Equals("]"))
{
iBalance -= 1;
}
if (iBalance == 0)
{
return(currentNode);
}
currentNode = currentNode.Previous;
} while (node.Previous != headNode.Previous);
}
else if (strBracket.Equals("["))
{
iBalance = 1;
LLinkedListNode <LTerm> currentNode = node;
do
{
if (currentNode.Value.Symbol.Equals("["))
{
iBalance += 1;
}
else if (currentNode.Value.Symbol.Equals("]"))
{
iBalance -= 1;
}
if (iBalance == 0)
{
return(currentNode);
}
currentNode = currentNode.Next;
} while (currentNode != headNode);
}
else //即不是左括号又不是右括号，则返回原来的节点
{
return(node);
}
throw new Exception("Missing left or right braket."); //节点个数不相等
}
/// <summary>
/// 往空链表（当前链表）插入一个节点
/// </summary>
/// <param name="node">待插入的节点</param>
private void InsertNodeToEmptyList(LLinkedListNode <T> node)
{
node.Previous = node;
node.Next = node;
m_head = node;
m_count++;
}
/// <summary>
/// 在一个节点之后添加一个节点
/// </summary>
/// <param name="node">在该节点后添加</param>
/// <param name="value">待添加节点的值</param>
/// <returns>添加后的节点</returns>
public LLinkedListNode <T> AddAfter(LLinkedListNode <T> node, T value)
{
LLinkedListNode <T> newNode = new LLinkedListNode <T>(value);
AddAfter(node, newNode);
return(newNode);
}
/// <summary>
/// 在单一节点的链表中将一个节点置换成另外一个节点
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="newNode">置换的节点</param>
private void ReplaceNodeWithNodeInSingleNodeList(LLinkedListNode <T> node, LLinkedListNode <T> newNode)
{
newNode.Previous = newNode; //前驱
newNode.Next = newNode; //后继
m_head = newNode;
//node.Invalidate(); //初始化被置换的节点
}
/// <summary>
/// 往一个节点之后插入一个节点
/// </summary>
/// <param name="node">在该节点之后插入</param>
/// <param name="newNode">待插入的节点</param>
private void InsertNodeToListAfter(LLinkedListNode <T> node, LLinkedListNode <T> newNode)
{
newNode.Previous = node;
newNode.Next = node.Next;
node.Next.Previous = newNode;
node.Next = newNode;
m_count++;
}
/// <summary>
/// 添加一个节点
/// </summary>
/// <param name="item">待添加的节点</param>
public void Add(LLinkedListNode <T> item)
{
if (m_head == null)
{
AddAfter(null, item);
}
else
{
AddAfter(m_head.Previous, item);
}
}
/// <summary>
/// 检验节点是否可用
/// </summary>
/// <param name="node">待检验的节点</param>
private void ValidateNode(LLinkedListNode <T> node)
{
if (node == null && m_count != 0)
{
throw new InvalidOperationException("The input node is NULL.");
}
if (node != null && m_count == 0)
{
throw new InvalidOperationException("The list is empty.");
}
}
/// <summary>
/// 清除
/// </summary>
public void Clear()
{
LLinkedListNode <T> node = m_head;
while (node != null)
{
LLinkedListNode <T> tempNode = node;
node = node.Next;
tempNode.Invalidate();
}
}
private bool isLeftContextual(LLinkedListNode <LTerm> node, out List <LTerm> FinnalLeftContext)
{
List <LTerm> LeftContext = m_Predecessor.LeftContext;
FinnalLeftContext = new List <LTerm>(); //初始化输出的链表
if (LeftContext == null || LeftContext.Count == 0) //无左侧的上下文
{
return(true);
}
int indexOfContext = LeftContext.Count - 1;
//LLinkedListNode<Term> headNode = Scene.GetInstance().TreeModel.RuleData.FinalList.First; //头节点
LLinkedListNode <LTerm> headNode = Belong.FinalList.First;
LLinkedListNode <LTerm> currentNode = node.Previous;
while (currentNode != headNode.Previous && indexOfContext >= 0) //当当前节点已经到达头结点或上下文的索引已超出范围
{
if (isIgnored(currentNode.Value) || currentNode.Value.Symbol.Equals("[")) //该节点为被无视节点
{
currentNode = currentNode.Previous;
continue;
}
if (currentNode.Value.Symbol.Equals("]")) //当当前节点的符号为“]”时，需要寻找与其匹配的“[”，而这中间的节点均无视（不属于节点的上下文）
{
currentNode = FindMatchingBracket(currentNode.Previous, "]").Previous;
continue;
}
if (currentNode.Value.Symbol.Equals(LeftContext[indexOfContext].Symbol) || LeftContext[indexOfContext].Symbol.Equals("*")) //与当前的上下文中的符号相同
{
FinnalLeftContext.Add(currentNode.Value); //添加最终结果链表中的结果，用于后续条件的计算
indexOfContext--; //检验前一个节点的符号是否相同
currentNode = currentNode.Previous;
}
else //与当前的上下文中的符号不匹配
{
return(false);
}
}
if (indexOfContext >= 0) //当当前节点已经到达头结点而上下文的索引还未能超出范围，说明节点的左侧上下文与匹配的左侧上下文个数不相等
{
return(false);
}
else
{
FinnalLeftContext.Reverse(); //翻转，因为是逆向插入
return(true);
}
}
/// <summary>
/// 在多节点的链表中将一个节点置换成另外一个节点
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="newNode">置换的节点</param>
private void ReplaceNodeWithNodeInMultiNodesList(LLinkedListNode <T> node, LLinkedListNode <T> newNode)
{
newNode.Previous = node.Previous; //前驱
newNode.Next = node.Next; //后继
node.Previous.Next = newNode;
node.Next.Previous = newNode;
if (m_head == node)
{
m_head = newNode;
}
}
/// <summary>
/// 将一个节点置换成另外一个链表
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="list">置换的链表</param>
public void Replace(LLinkedListNode <T> node, LLinkedList <T> list)
{
ValidateNode(node);
if (m_count == 1)
{
ReplaceNodeWithListInSingleNodeList(node, list);
}
else
{
ReplaceNodeWithListInMultiNodesList(node, list);
}
}
/// <summary>
/// 将一个节点置换成另外一个节点
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="newNode">置换的节点</param>
public void Replace(LLinkedListNode <T> node, LLinkedListNode <T> newNode)
{
ValidateNode(node); //对列表中的节点进行检查
if (m_count == 1)
{
ReplaceNodeWithNodeInSingleNodeList(node, newNode);
}
else
{
ReplaceNodeWithNodeInMultiNodesList(node, newNode);
}
}
/// <summary>
/// 在一个节点之后添加一个节点
/// </summary>
/// <param name="node">在该节点后添加</param>
/// <param name="newNode">待添加的节点</param>
public void AddAfter(LLinkedListNode <T> node, LLinkedListNode <T> newNode)
{
ValidateNode(node); //对列表中的节点进行检查
if (m_count == 0) //列表为空
{
InsertNodeToEmptyList(newNode);
}
else //列表不为空
{
InsertNodeToListAfter(node, newNode);
}
}
public T[] ToArray()
{
T[] result = new T[Count];
LLinkedListNode <T> node = m_head;
for (int i = 0; i < Count; i++)
{
result[i] = node.Value;
node = node.Next;
}
return(result);
}
/// <summary>
/// 往一个节点之后插入一个链表
/// </summary>
/// <param name="node">在该节点之后插入</param>
/// <param name="list">待插入的节点</param>
private void InsertListToListAfter(LLinkedListNode <T> node, LLinkedList <T> list)
{
LLinkedListNode <T> listHead = list.First;
LLinkedListNode <T> listEnd = list.Last;
//链表头尾变化
listHead.Previous = node;
listEnd.Next = node.Next;
node.Next.Previous = listEnd;
node.Next = listHead;
m_count += list.Count;
}
/// <summary>
/// 在一个节点之后添加一个链表
/// </summary>
/// <param name="node">在该节点之后添加</param>
/// <param name="list">待添加的链表</param>
public void AddAfter(LLinkedListNode <T> node, LLinkedList <T> list)
{
ValidateNode(node); //对列表中的节点进行检查
LLinkedList <T> tempList = list.Clone();
if (m_count == 0)
{
InsertListToEmptyList(tempList);
}
else
{
InsertListToListAfter(node, tempList);
}
}
/// <summary>
/// 判断是否符合上下文条件
/// </summary>
/// <returns></returns>
private bool isContextual(LLinkedListNode <LTerm> node, out List <LTerm> FinnalLeftContext, out List <LTerm> FinnalRightContext)
{
if (!isLeftContextual(node, out FinnalLeftContext)) //判断左侧上下文是否符合条件
{
FinnalRightContext = new List <LTerm>();
return(false);
}
if (!isRightContextual(node, out FinnalRightContext)) //判断右侧上下文是否符合条件
{
return(false);
}
return(true);
}
public List <T> ToList()
{
List <T> result = new List <T>();
LLinkedListNode <T> node = m_head;
do
{
result.Add(node.Value);
node = node.Next;
} while (node != m_head);
return(result);
}
/// <summary>
/// 将当前链表克隆
/// </summary>
/// <returns></returns>
public LLinkedList <T> Clone()
{
LLinkedList <T> resultList = new LLinkedList <T>();
LLinkedListNode <T> srcNode = m_head; //源节点从该链表的头结点开始
do
{
LLinkedListNode <T> destNode = new LLinkedListNode <T>(srcNode.Value); //复制源节点的值，不复制其前驱和后继
resultList.Add(destNode); //插入复制后的节点
srcNode = srcNode.Next; //移动到下一个节点
} while (srcNode != m_head); //当源节点重新回归到头结点时，停止复制
return(resultList);
}
/// <summary>
/// 在多节点的链表中将一个节点置换成另外一个链表
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="list">置换的链表</param>
private void ReplaceNodeWithListInMultiNodesList(LLinkedListNode <T> node, LLinkedList <T> list)
{
LLinkedListNode <T> listHead = list.First; //首节点
LLinkedListNode <T> listEnd = list.Last; //尾节点
listHead.Previous = node.Previous;
listEnd.Next = node.Next;
node.Previous.Next = listHead;
node.Next.Previous = listEnd;
if (m_head == node)
{
m_head = listHead;
}
m_count += (list.Count - 1);
}
public override string ToString()
{
if (m_count == 0)
{
return(""); //列表为空
}
string result = "";
LLinkedListNode <T> node = m_head;
do
{
if (node.Value != null)
{
result += node.Value.ToString();
}
node = node.Next;
} while (node != m_head);
return(result);
}
/// <summary>
/// 采用多线程的方式快速迭代
/// </summary>
private void ReplaceFinalListFast()
{
LLinkedListNode <LTerm> node = m_listFinal.First; //从头节点开始
LLinkedListNode <LTerm> head = m_listFinal.First; //头节点
LLinkedListNode <LTerm>[] nodes = new LLinkedListNode <LTerm> [m_listFinal.Count];
LLinkedList <LTerm>[] resultLists = new LLinkedList <LTerm> [m_listFinal.Count];
for (int i = 0; i < m_listFinal.Count; i++)
{
nodes[i] = new LLinkedListNode <LTerm>(node.Value);
node = node.Next;
}
Parallel.For(0, m_listFinal.Count, i =>
{
resultLists[i] = GetResultListFrom(nodes[i]);
});
LLinkedList <LTerm> FinalList = new LLinkedList <LTerm>();
for (int i = 0; i < resultLists.Length; i++)
{
if (resultLists[i] == null)
{
FinalList.Add(nodes[i]);
}
else
{
FinalList.Add(resultLists[i]);
}
}
m_listFinal = FinalList;
}
/// <summary>
/// 将一个节点置换成另外一个节点
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="value">置换节点的值</param>
public void Replace(LLinkedListNode <T> node, T value)
{
Replace(node, new LLinkedListNode <T>(value));
}
/// <summary>
/// 往空链表（当前链表）插入一个链表
/// </summary>
/// <param name="list">待插入的链表</param>
private void InsertListToEmptyList(LLinkedList <T> list)
{
m_head = list.First;
m_count = list.Count;
}
/// <summary>
/// 在单一节点的链表中将一个节点置换成另外一个链表
/// </summary>
/// <param name="node">被置换的节点</param>
/// <param name="list">置换的链表</param>
private void ReplaceNodeWithListInSingleNodeList(LLinkedListNode <T> node, LLinkedList <T> list)
{
m_head = list.First; //当前链表的头节点与置换链表的头节点相同
m_count = list.Count; //当前链表的节点数与置换链表的节点数相同
}
public void Invalidate()
{
m_prev = null;
m_next = null;
m_value = null;
}
private bool isRightContextual(LLinkedListNode <LTerm> node, out List <LTerm> FinalRightContext)
{
List <LTerm> RigthContext = m_Predecessor.RightContext;
FinalRightContext = new List <LTerm>();
if (RightContext == null || RightContext.Count == 0) //无右侧的上下文
{
return(true);
}
int indexOfContext = 0;
LLinkedListNode <LTerm> headNode = Belong.FinalList.First;
//Scene.GetInstance().TreeModel.RuleData.FinalList.First; //头节点
LLinkedListNode <LTerm> currentNode = node.Next;
while (currentNode != headNode && indexOfContext < RigthContext.Count) //当当前节点已经到达头结点或上下文的索引已超出范围
{
if (isIgnored(currentNode.Value)) //该节点为被无视节点
{
currentNode = currentNode.Next;
continue;
}
//当字符串为A[A]B时，前驱为A > B --> B
//第一个A有两个后续，括号中的A和不在括号中的B
//前驱的右侧上下文只匹配不在括号中的B，因此要跳过[A]
if (!RigthContext[indexOfContext].Symbol.Equals("[") && currentNode.Value.Symbol.Equals("["))
{
currentNode = FindMatchingBracket(currentNode.Next, "[").Next;
continue;
}
if (RigthContext[indexOfContext].Symbol.Equals("]"))
{
//假设前驱是 S > G[H]M， 字符串为 SG[HI[JK]L]MNO
//当前的RightContext[indexOfContext]为G[H]M中的]
//当前的节点currentNode为I
//需要跳过H后续的I[JK]L，因此需要寻找L后的“]”
currentNode = FindMatchingBracket(currentNode, "[");
}
if (currentNode.Value.Symbol.Equals(RightContext[indexOfContext].Symbol)) //与当前的上下文中的符号相同
{
FinalRightContext.Add(currentNode.Value); //插入最终结果链表的结果，用于后续条件的计算
indexOfContext++; //检验后一个节点的符号是否相同
currentNode = currentNode.Next;
}
else if (!currentNode.Value.Symbol.Equals("]") && RigthContext[indexOfContext].Symbol.Equals("*")) //与任意字符匹配
{
FinalRightContext.Add(currentNode.Value);
indexOfContext++;
currentNode = currentNode.Next;
}
else //与当前的上下文中的符号不匹配
{
return(false);
}
}
if (indexOfContext < RigthContext.Count) //当当前节点已经到达头结点而上下文的索引还未能超出范围，说明节点的左侧上下文与匹配的左侧上下文个数不相等
{
return(false);
}
else
{
return(true);
}
}
/// <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);
}
