/// <summary>
/// Добавляет новое правило в сеть.
/// </summary>
/// <param name="statement">Новое правило.</param>
/// <param name="parent">Текущий родитель.</param>
/// <param name="end">Конечный нод сети.</param>
public virtual void AddStatement(ProductionRule statement, ReteNode parent, AgendaNode end)
{
foreach (var output in outputs)
{
output.AddStatement(statement, this, end);
}
}
/// <summary>
/// Добавляет новое правило в сеть.
/// </summary>
/// <param name="statement">Новое правило.</param>
/// <param name="parent">Текущий родитель.</param>
/// <param name="end">Конечный нод сети.</param>
public override void AddStatement(ProductionRule statement, ReteNode parent, AgendaNode end)
{
if (this.outputs.Count == 0)
{
this.outputs.Add(new BetaMemoryNode());
this.outputs[0].Inputs.Add(this);
}
base.AddStatement(statement, parent, end);
}
/// <summary>
/// Добавляет новое правило в сеть.
/// </summary>
/// <param name="statement">Новое правило.</param>
/// <param name="parent">Текущий родитель.</param>
/// <param name="end">Конечный нод сети.</param>
public override void AddStatement(ProductionRule statement, ReteNode parent, AgendaNode end)
{
if (!this.outputs.Any((a) => { return(a is BetaMemoryNode); }))
{
this.outputs.Add(new BetaMemoryNode());
this.outputs.Last().Inputs.Add(this);
}
base.AddStatement(statement, this, end);
}
/// <summary>
/// Проверяет истинность логического высказывания.
/// </summary>
/// <param name="statement">Логическое утверждение..</param>
/// <returns>
/// Возвращает <c>true</c>, если правило можно выполнить.
/// </returns>
public override bool CheckStatement(ILogicalStatement statement)
{
ProductionRule rule = (ProductionRule)statement;
foreach (string variableName in rule.Condition.VariableNames)
{
foreach (var fact in workMemory)
{
rule.Condition.SetVariable(fact.Name, fact);
}
}
return(rule.Condition.Calculate() == true);
}
/// <summary>
/// Добавляет новое правило в сеть.
/// </summary>
/// <param name="statement">Новое правило.</param>
/// <param name="parent">Текущий родитель.</param>
/// <param name="end">Конечный нод сети.</param>
public override void AddStatement(ProductionRule statement, ReteNode parent, AgendaNode end)
{
if (outputs[0] == null)
{
outputs[0] = end;
end.Inputs.Add(this);
}
if (!betaMemory.Contains(statement.Name))
{
betaMemory.Add(statement.Name);
}
base.AddStatement(statement, parent, end);
}
protected void AddAndMerge(IEnumerable <Expression> conditions, ProductionRule statement,
AgendaNode end)
{
List <ReteNode> exist = new List <ReteNode>(); //список уже существующих нодов
List <ReteNode> add = new List <ReteNode>(); // список новых нодов
foreach (var c in conditions) //находим уже сущеcтвующие Alpha ноды
{
AlphaNode n = null;
if (FindNode(c, out n)) // если нод существует, то добавляем его к списку существующих
{
exist.Add(n);
}
else
{
AlphaNode n1 = new AlphaNode(); //иначе создаём новый
n1.Predicate = c;
n1.Inputs[0] = this; //связываем его с корнем
this.outputs.Add(n1);
add.Add(n1); //добавляем его в список новых нодов
}
}
exist = Commonize(exist); //находим наиболее общих наследников
foreach (var n in add) //теперь всё в одном списке
{
exist.Add(n);
}
while (exist.Count > 1) //объединяем всё, что осталось
{
ReteNode n1 = exist[0];
ReteNode n2 = exist[1];
exist.RemoveAt(0);
exist.RemoveAt(0);
ReteNode unuion = n1.Merge(n2);
exist.Add(unuion);
}
BetaMemoryNode bm =
(BetaMemoryNode)exist[0].Outputs.FirstOrDefault((a) => { return(a is BetaMemoryNode); });
if (bm == null)
{
bm = new BetaMemoryNode();
bm.Outputs[0] = end;
bm.Inputs.Add(exist[0]);
exist[0].Outputs.Add(bm);
}
if (!bm.BetaMemory.Contains(statement.Name))
{
bm.BetaMemory.Add(statement.Name);
}
}
public void AddStatement(Expression expression, ProductionRule statement, AgendaNode end)
{
Expression left = null;
Expression right = null;
if (expression.SplitOr(out left, out right)) //если в корне выражения оператор "или"
{
//добавляем две новые ветви с текущим правилом в конце
AddStatement(left, statement, end);
AddStatement(right, statement, end);
}
else //в корне либо конъюнкция, либо атомарное условие
{
//получаем все конъюнкты
IEnumerable <Expression> simpleConditions = null;
expression.SplitFactConjunction(out simpleConditions);
//и пытаемся слить их вместе в новую ветвь
AddAndMerge(simpleConditions, statement, end);
}
}
public bool CheckConflict(ProductionRule rule1, ProductionRule rule2)
{
List <Expression> sentences = new List <Expression>();
//строим КНФ из условия первого выражения и зачёркиваем знаки конъюнкции
foreach (var exp in eh.GetConjunctCollection(eh.GetCNF(rule1.Condition)))
{
sentences.Add(exp);
}
//делаем то же самое со вторым правилом
foreach (var exp in eh.GetConjunctCollection(eh.GetCNF(rule2.Condition)))
{
sentences.Add(exp);
}
//для каждого действия в правой части первого правила
foreach (var action in rule1.Actions)
{
var addFact = action as AddFactAction;
//если действие в правой части - добавление факта
if (addFact != null)
{
//строим отрицание выражения по факту и добавляем его
sentences.Add(eh.CreateExpression("!" + addFact.ToString()));
}
}
//для каждого действия в правой части второго правила
foreach (var action in rule2.Actions)
{
var addFact = action as AddFactAction;
//если действие в правой части - добавление факта
if (addFact != null)
{
//строим отрицание выражения по факту и добавляем его
sentences.Add(eh.CreateExpression("!" + addFact.ToString()));
}
}
return(Resolve(sentences));
}
public override void AddStatement(ProductionRule statement, ReteNode parent, AgendaNode end)
{
AddStatement(statement.Condition, statement, end);
}
