/// <summary> /// On a left activation /// (when there is a new match for all the earlier conditions), we build and store a new token, perform /// a join for the token, store the join results in the token structure, and pass the token onto any /// successor nodes if there were no join results. /// </summary> /// <param name="node">The node.</param> /// <param name="t">The t.</param> /// <param name="w">The w.</param> private void negative_node_left_activation(NegativeNode node, Token t, WME w) { // *** Right Unlinking *** if (node.Items.Count == 0) relink_to_alpha_memory(node); // *** End Right Unlinking *** Token new_token = make_token(node, t, w); node.Items.AddToFront(new_token); foreach (ItemInAlphaMemory item in node.AlphaMemory.Items) { if (perform_join_tests(node.Tests, new_token, item.WME)) { NegativeJoinResult jr = new NegativeJoinResult(); jr.Owner = new_token; jr.WME = w; new_token.JoinResults.AddToFront(jr); w.NegativeJoinResults.AddToFront(jr); } } if (new_token.JoinResults.Count == 0) { foreach (ReteNode child in node.Children) { left_activation(child, new_token, null); } } }
/// <summary> /// Builtin_node_left_activations the specified memory. /// </summary> /// <param name="memory">The memory.</param> /// <param name="tok">The tok.</param> /// <param name="w">The w.</param> private void builtin_node_left_activation(BuiltinMemory memory, Token tok, WME w) { Token new_token = make_token(memory, tok, w); memory.Items.AddToFront(new_token); if (memory.PerformEvaluation(new_token)) { foreach (ReteNode child in memory.Children) { left_activation(child, new_token, w); } } }
/// <summary> /// Adds the fact. /// </summary> /// <param name="fact">The fact to the initial facts list.</param> public void AddFact(WME fact) { _initialFacts.Add(fact); }
/// <summary> /// Now, to remove a WME, we just remove it from each alpha memory containing it (these /// alpha memories are now conveniently on a list) and call the helper routine delete-token-and- /// descendents to delete all the tokens involving it (all the necessary "root" tokens involving it are /// also conveniently on a list): /// </summary> /// <param name="wme">The wme.</param> public void RemoveWME(WME wme) { int pos = _working_memory.IndexOf(wme); if (pos < 0) return; WME w = _working_memory[pos]; foreach (ItemInAlphaMemory item in w.AlphaMemoryItems) { item.AlphaMemory.Items.Remove(item); // *** Left Unlinking *** if (item.AlphaMemory.Items.Count == 0) { foreach (ReteNode node in item.AlphaMemory.Successors) { if (node.Type == ReteNodeType.Join) { node.Parent.Children.Remove(node); ((JoinNode) node).IsLeftUnlinked = true; } } } // *** End Left Unlinking *** } while (w.Tokens.Count > 0) { delete_token_and_descendents(w.Tokens[0]); } foreach (NegativeJoinResult jr in w.NegativeJoinResults) { jr.Owner.JoinResults.Remove(jr); if (jr.Owner.JoinResults.Count == 0) { foreach (ReteNode child in jr.Owner.Node.Children) { left_activation(child, jr.Owner, null); } } } _working_memory.Remove(w); }
/// <summary> /// Whenever a new WME is filtered through the alpha network and reaches an alpha memory, we /// simply add it to the list of other WMEs in that memory, and inform each of the attached join /// nodes: /// </summary> /// <param name="node">The node.</param> /// <param name="w">The w.</param> private void alpha_memory_activation(AlphaMemory node, WME w) { ItemInAlphaMemory new_item = new ItemInAlphaMemory(); new_item.WME = w; new_item.AlphaMemory = node; node.Items.Add(new_item); w.AlphaMemoryItems.AddToFront(new_item); // *** Neo Integration *** if (w.Value.TermType == TermType.EntityObject) { IFactProvider eo = (IFactProvider) w.Value.Value; if (eo.MyFactsHaveBeenAsserted == false) { foreach (WME wme in eo.GenerateFactsForRelatedObject(w.Attribute.Value.ToString(), w.Identifier.Value as IFactProvider)) { AddWME(wme); } } } if (w.Value.TermType == TermType.ObjectRelation) { ObjectRelationBase orb = (ObjectRelationBase) w.Value.Value; foreach (RulesEnabledEntityObject eo in orb) { if (eo.MyFactsHaveBeenAsserted == false) { foreach (WME wme in eo.GenerateFactsForObjectInCollection(w.Attribute.Value.ToString(), orb)) { AddWME(wme); } } } } // *** End Neo Integration *** //The unlinking process changes the underlying collection so we need a new collection... BigList<ReteNode> successors = node.Successors.Clone(); foreach (ReteNode successor in successors) { right_activation(successor, w); } }
/// <summary> /// P_node_activations the specified node. /// </summary> /// <param name="node">The node.</param> /// <param name="tok">The tok.</param> /// <param name="w">The w.</param> private void p_node_activation(ProductionNode node, Token tok, WME w) { Token new_token = make_token(node, tok, w); node.Items.AddToFront(new_token); int lhsCnt = node.Production.Lhs.Count - 1; foreach (RightHandSideCondition rhsCondition in node.Production.Rhs) { WME newfact = new WME(); for (int f = 0; f < 3; f++) { Term term = rhsCondition.Fields[f]; if (term.TermType == TermType.Variable) { for (int i = lhsCnt; i >= 0; i--) { Condition lhsCondition = node.Production.Lhs[i]; if (lhsCondition.ConditionType == ConditionType.Positive) { int pos = lhsCondition.Contains(term); if (pos >= 0) { Token tok2 = new_token.GetTokenUp(lhsCnt - i); newfact.Fields[f] = tok2.WME[pos]; i = -1; } } } } else { newfact.Fields[f] = term; } } Activation newact = new Activation(newfact, rhsCondition.ConditionType); if (node.Production.InferredFacts.Contains(newact) == false) { node.Production.InferredFacts.Add(newact); } } }
/// <summary> /// Controls the activation flow based on node type /// </summary> /// <param name="child">The child.</param> /// <param name="w">The w.</param> private void right_activation(ReteNode child, WME w) { switch (child.Type) { case ReteNodeType.Join: join_node_right_activation(child as JoinNode, w); break; case ReteNodeType.Negative: negative_node_right_activation(child as NegativeNode, w); break; default: throw new ApplicationException("???"); } }
/// <summary> /// Initializes a new instance of the <see cref="DummyTopToken"/> class. /// </summary> public DummyTopToken() { _wme = new WME("null"); }
/// <summary> /// Initializes a new instance of the <see cref="DummyTopToken"/> class. /// </summary> public DummyTopToken() { _wme = new WME("null"); }
/// <summary> /// Binds the RHS. /// </summary> private void BindRHS(List<Activation> items) { int lhsCnt = _lhs.Count - 1; foreach (Activation act in items) { foreach (RightHandSideCondition condition in _rhs) { WME newfact = new WME(); for (int f = 0; f < 3; f++) { Term term = condition.Fields[f]; if (term.TermType == TermType.Variable) { for (int i = lhsCnt; i >= 0; i--) { Condition rh = _lhs[i]; if (rh.ConditionType == ConditionType.Positive) { int pos = rh.Contains(term); if (pos >= 0) { newfact.Fields[f] = act.InferredFact[pos]; i = -1; } } } } else { newfact.Fields[f] = term; } } Activation newact = new Activation(newfact, condition.ConditionType); if (_inferredFacts.Contains(newact) == false) { _inferredFacts.Add(newact); } } } }
/// <summary> /// Initializes a new instance of the <see cref="Activation"/> class. /// </summary> /// <param name="prod">The prod.</param> /// <param name="tok">The tok.</param> public Activation(WME prod, ConditionType tok) { _fact = prod; _conditionType = tok; }
/// <summary> /// Sets the specified fact. /// </summary> /// <param name="fact">The fact.</param> private void Set(WME fact) { IFactProvider eo = fact.Identifier.Value as IFactProvider; if (eo == null) { return; } try { eo.SetProperty(fact.Attribute.Value.ToString(), fact.Value.Value); _actionsTaken.Add(fact); } catch { _actionsSkipped.Add(fact); } }
/// <summary> /// Retracts the specified fact. /// </summary> /// <param name="fact">The fact.</param> private void Retract(WME fact) { _inferredFacts.Remove(fact); _rete.RemoveWME(fact); }
/// <summary> /// Asserts the specified fact. /// </summary> /// <param name="fact">The fact.</param> private void Assert(WME fact) { _inferredFacts.Add(fact); _rete.AddWME(fact); }
/// <summary> /// On a right activation of a negative node (when a WME is added to its alpha memory), /// we look for any tokens in its memory consistent with the WME; for each such token, we add /// this WME to its local result memory. Also, if the number of results changes from zero to /// one - indicating that the negated condition was previously true but is now false - then we /// call the delete-descendents-of-token helper function to delete any tokens lower in the network /// that depend on this token. /// </summary> /// <param name="node">The node.</param> /// <param name="w">The w.</param> private void negative_node_right_activation(NegativeNode node, WME w) { foreach (Token t in node.Items) { if (perform_join_tests(node.Tests, t, w)) { if (t.JoinResults.Count == 0) { delete_descendents_of_token(t); } NegativeJoinResult jr = new NegativeJoinResult(); jr.Owner = t; jr.WME = w; t.JoinResults.AddToFront(jr); w.NegativeJoinResults.AddToFront(jr); } } }
/// <summary> /// Upon a right activation (when a new WME w is added to the alpha memory), we look /// through the beta memory and find any token(s) t for which all these t-versus-w tests succeed. /// Any successful (t;w) combinations are passed on to the join node's children. /// </summary> /// <param name="node">The node.</param> /// <param name="w">The w.</param> private void join_node_right_activation(JoinNode node, WME w) { // *** Left Unlinking *** if (node.IsLeftUnlinked) { relink_to_beta_memory(node); if (((BetaMemory) node.Parent).Items.Count == 0) { node.AlphaMemory.Successors.Remove(node); node.IsRightUnlinked = true; } } // *** End Left Unlinking *** foreach (Token t in ((BetaMemory) node.Parent).Items) { if (perform_join_tests(node.Tests, t, w)) { foreach (ReteNode child in node.Children) { left_activation(child, t, w); } } } }
/// <summary> /// Performs the specified tests. /// </summary> /// <param name="tests">The tests.</param> /// <param name="t">The t.</param> /// <param name="w">The w.</param> /// <returns></returns> private bool perform_join_tests(IEnumerable<TestAtJoinNode> tests, Token t, WME w) { foreach (TestAtJoinNode this_test in tests) { Term arg1 = w[this_test.FieldOfArg1]; WME wme2 = t[this_test.NumberOfLevelsUp]; Term arg2 = wme2[this_test.FieldOfArg2]; if (this_test.Evaluator.Evaluate(arg1, arg2) == false) return false; } return true; }
/// <summary> /// Left_activations the specified new_node. /// </summary> /// <param name="new_node">The new_node.</param> /// <param name="tok">The tok.</param> /// <param name="w">The w.</param> private void left_activation(ReteNode new_node, Token tok, WME w) { switch (new_node.Type) { case ReteNodeType.BetaMemory: beta_memory_left_activation(new_node as BetaMemory, tok, w); break; case ReteNodeType.Negative: negative_node_left_activation(new_node as NegativeNode, tok, w); break; case ReteNodeType.Builtin: builtin_node_left_activation(new_node as BuiltinMemory, tok, w); break; case ReteNodeType.NCCPartner: ncc_partner_node_left_activation(new_node as NCCPartnerNode, tok, w); break; case ReteNodeType.NCC: ncc_node_left_activation(new_node as NCCNode, tok, w); break; case ReteNodeType.Join: join_node_left_activation(new_node as JoinNode, tok); break; case ReteNodeType.Production: p_node_activation(new_node as ProductionNode, tok, w); break; case ReteNodeType.Mutex: mutex_node_activation(new_node as MutexNode, tok, w); break; case ReteNodeType.Aggregator: aggregator_node_activation(new_node as AggregatorNode, tok, w); break; default: throw new ApplicationException("Unknown left_activation type: " + new_node.GetType().Name); } }
/// <summary> /// Adds the WME. /// </summary> /// <param name="w">The WME.</param> public void AddWME(WME w) { int v1 = w.Fields[0].GetHashCode(); int v2 = w.Fields[1].GetHashCode(); int v3 = w.Fields[2].GetHashCode(); _working_memory.Add(w); AlphaMemory alpha_mem; alpha_mem = lookup_in_hash_table(0, 0, 0); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(0, 0, v3); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(0, v2, 0); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(0, v2, v3); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(v1, 0, 0); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(v1, 0, v3); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(v1, v2, 0); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); alpha_mem = lookup_in_hash_table(v1, v2, v3); if (alpha_mem != null) alpha_memory_activation(alpha_mem, w); }
/// <summary> /// Similarly, whenever a new token tok = ht;wi is added to a beta memory, we add tok to /// t.children and to w.tokens. We also fill in the new node field on the token. To simplify our /// pseudocode, it is convenient to define a "helper" function make-token which builds a new token /// and initializes its various fields as necessary for tree-based removal. Although we write this as /// a separate function, it would normally be coded "inline" for efficiency. /// </summary> /// <param name="node">The node.</param> /// <param name="parent">The parent.</param> /// <param name="w">The w.</param> /// <returns></returns> private Token make_token(ReteNode node, Token parent, WME w) { Token tok = new Token(); tok.Parent = parent; tok.WME = w; tok.Node = node; parent.Children.AddToFront(tok); if (w != null) { w.Tokens.AddToFront(tok); } return tok; }
/// <summary> /// Modifies an existing WME. /// </summary> /// <param name="oldWME">The old WME.</param> /// <param name="newWME">The new WME.</param> public virtual void ModifyWME(WME oldWME, WME newWME) { RemoveWME(oldWME); AddWME(newWME); }
/// <summary> /// Mutex_node_activations the specified node. /// </summary> /// <param name="node">The node.</param> /// <param name="tok">The tok.</param> /// <param name="w">The w.</param> private void mutex_node_activation(MutexNode node, Token tok, WME w) { Token new_token = make_token(node, tok, w); node.Items.Add(new_token); }
private void aggregator_node_activation(AggregatorNode node, Token tok, WME w) { Token new_token = make_token(node, tok, w); node.Items.AddToFront(new_token); }
/// <summary> /// Ncc_node_left_activations the specified node. /// </summary> /// <remarks> /// Our ncc-node-left-activation procedure is similar to the negative-node-left-activation procedure /// (page 42). In both cases, we need to find the join results for a new token. For negative /// nodes, we compute these join results by scanning the WMEs in an alpha memory and performing /// the join tests on them. For NCC nodes, the join results have already been computed by the /// subnetwork, so we simply look at the new-result-buffer in the NCC partner node to find them. /// </remarks> /// <param name="node">The node.</param> /// <param name="t">The t.</param> /// <param name="w">The w.</param> private void ncc_node_left_activation(NCCNode node, Token t, WME w) { Token new_token = make_token(node, t, w); node.Items.AddToFront(new_token); foreach (Token result in node.Partner.NewResultBuffer) { node.Partner.NewResultBuffer.Remove(result); new_token.NCCResults.AddToFront(result); result.Owner = new_token; } if (new_token.NCCResults.Count == 0) { foreach (ReteNode child in node.Children) { left_activation(child, new_token, null); } } }
/// <summary> /// Whenever a beta memory is informed of a new match (consisting of an existing token and some /// WME), we build a token, add it to the list in the beta memory, and inform each of the beta /// memory's children: /// </summary> /// <param name="node">The node.</param> /// <param name="t">The token.</param> /// <param name="w">The wme.</param> private void beta_memory_left_activation(BetaMemory node, Token t, WME w) { Token new_token = make_token(node, t, w); node.Items.Add(new_token); //The unlinking process changes the underlying collection so we need a new collection... BigList<ReteNode> children = node.Children.Clone(); foreach (ReteNode child in children) { left_activation(child, new_token, null); } }
/// <summary> /// Ncc_partner_node_left_activations the specified partner. /// </summary> /// <remarks> /// To handle an NCC partner node (left) activation, we take the new match from the subnetwork /// and build a "result" token to store it. (The pseudocode for this is shown in Figure 2.8.) Next we /// try to find the appropriate owner token in the NCC node's memory. (There might be one there, /// if this is a new subconditions match for an old preceding-conditions match, or there might not /// be one there, if this is an initial subconditions match for a new preceding-conditions match.) /// If we find an appropriate owner token, then we add the new result token to its local memory; /// if the number of results in the local memory changes from zero to one | indicating that the /// NCC was previously true but is now false | then we call the delete-descendents-of-token helper /// function to delete any tokens lower in the network that depend on this owner token. (This is /// similar to the negative-node-right-activation procedure on page 43.) On the other hand, if there /// isn't an appropriate owner token already in the NCC node's memory, then this new result token /// is placed in the new-result-buffer. (The NCC node will soon be activated and collect any new /// results from the buffer.) /// </remarks> /// <param name="partner">The partner.</param> /// <param name="t">The t.</param> /// <param name="w">The w.</param> private void ncc_partner_node_left_activation(NCCPartnerNode partner, Token t, WME w) { NCCNode nccNode = partner.NCCNode; Token new_result = make_token(partner, t, w); Token owners_t = t; WME owners_w = w; for (int i = 0; i < partner.NumberOfConjuncts; i++) { owners_w = owners_t.WME; owners_t = owners_t.Parent; } foreach (Token owner in nccNode.Items) { if (owner.Parent == owners_t && owner.WME == owners_w) { owner.NCCResults.Add(new_result); new_result.Owner = owner; delete_descendents_of_token(owner); } else { partner.NewResultBuffer.AddToFront(new_result); } } }
/// <summary> /// Check_constant_testses the specified w. /// </summary> /// <param name="w">The w.</param> /// <param name="c">The c.</param> /// <returns></returns> private bool check_constant_tests(WME w, Condition c) { foreach (Term o in c.Fields) { if ((o is Variable) == false) { if (w.Contains(o) == false) return false; } } return true; }
/// <summary> /// Initializes a new instance of the <see cref="Activation"/> class. /// </summary> /// <param name="prod">The prod.</param> /// <param name="tok">The tok.</param> public Activation(WME prod, ConditionType tok) { _fact = prod; _conditionType = tok; }