// T_1 --> C_1 --> S_1 // T_2 --> C_2 --> S_2 // T_3 --> C_3 --> S_3 // T_1 --> C_1 --> S_New // T_2 --> C_1 // T_3 --> C_1 public void Merge() { Unifier un = new Unifier(new TypeFactory()); DataType dt = null; foreach (StructureType str in structures) { dt = un.Unify(dt, str); } StructureType strNew = (StructureType) dt; eqMin.DataType = strNew; }
public TypedExpressionRewriter(Program prog) { this.prog = prog; this.platform = prog.Platform; this.store = prog.TypeStore; this.globals = prog.Globals; this.compTypes = new DataTypeComparer(); this.tcr = new TypedConstantRewriter(prog); this.m = new ExpressionEmitter(); this.unifier = new Unifier(); }
public override object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); ts.GetAgent().Abolish((Literal)args[0], un); return(true); }
public void setUp() { parser = new FOLParser(DomainFactory.knowsDomain()); unifier = new Unifier(); theta = CollectionFactory.CreateInsertionOrderedMap <Variable, Term>(); }
public static IEnumerator <Unifier> AllDesires(Circumstance C, Literal l, ITerm intAsTerm, Unifier un) { Trigger teFroml = new Trigger(TEOperator.add, TEType.achieve, l); return(new EnumeratorImpl(C, l, intAsTerm, un, teFroml)); }
public virtual object Execute(Reasoner reasoner, Unifier un, ITerm[] args) { return(false); }
public bool Occurs(string s, object o) { return(Unifier.OccurCheck(new Variable(s), o)); }
public FOLKnowledgeBase(FOLDomain domain, InferenceProcedure inferenceProcedure, Unifier unifier) { this.parser = new FOLParser(new FOLDomain(domain)); this.inferenceProcedure = inferenceProcedure; this.unifier = unifier; // this.substVisitor = new SubstVisitor(); this.variableCollector = new VariableCollector(); this._standardizeApart = new StandardizeApart(variableCollector, substVisitor); this.cnfConverter = new CNFConverter(parser); }
/**************************************************************************/ /* * Returns a clone of this term with changes applied (it replaces variables by their value in the unifier), both operations together. * This double operation should be faster than 'Clone' and then 'Apply'. * u - The unifier */ public virtual ITerm CApply(Unifier u) { // It call Clone specific method, not (ITerm)MemberwiseClone() return((ITerm)Clone()); // Como uso el Clone de C# lo que clono son object que luego hay que castear... }
public object AllDesires(Circumstance circumstance, Literal body, object p, Unifier unifier) { throw new NotImplementedException(); }
public MethodBaseGetCurrentMethodThunkCache() { _cache = new Unifier(); }
public override object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); return(un.Unifies(args[2], ((IListTerm)args[0]).Difference((IListTerm)args[1]))); }
/* * @Override * public Object execute(TransitionSystem ts, Unifier un, Term[] args) throws Exception { * checkArguments(args); * StringBuffer sb = new StringBuffer(); * for (Term term : args) { * if (!term.isString()) { * continue; * } * StringTerm st = (StringTerm) term; * Matcher matcher = regex.matcher(st.getString()); * * while (matcher.find()) { * * //System.out.println("I found the text \""+matcher.group()+ "\"starting at index "+matcher.start()+ " and ending at index "+matcher.end()); * * String sVar = matcher.group(); * sVar = sVar.substring(2, sVar.length() - 1); //Quita los dos primeros caracteres: # y \, creo que es lo primero que aparece en las variables; y también quita el último: \ * try { * Term t = null; * if (sVar.startsWith("_") && sVar.length() > 1) // deals with unnamed vars, where we cannot use parseTerm * t = new UnnamedVar( Integer.valueOf( sVar.substring(1))); //Le quita la _ al nombre de la variable anónima * else * t = ASSyntax.parseTerm(sVar); //si no ya si que llama al término * * //We use t.apply to evaluate any logical or arithmetic expression in Jason * t = t.capply(un); * matcher.appendReplacement(sb, t.isString() ? ((StringTerm)t).getString() : t.toString()); * } catch (ParseException pe) { * // TODO: handle exception * // TODO: Decide whether or not we should ignore the exception and print the call instead * // Right now, if I get a parse error from ASSyntax, I just print the original escaped * // sequence, so a user can see that his/her expression was problematic * matcher.appendReplacement(sb, "#{"+sVar+"}"); * } * * } * matcher.appendTail(sb); * } * * if (args[args.length - 1].isVar()) { * //Guardar el mensaje todo ello unificado en una sola variable, para depurar * StringTerm stRes = new StringTermImpl(sb.toString()); * return un.unifies(stRes, args[args.length - 1]); * } else { * //Si no hay una variable, lo que quiero es sacar por pantalla todo el mensaje completo * ts.getLogger().info(sb.toString()); //Aquí es por donde se saca por la consola lo que el progrmamador haya querido en su asl * return true; * } * } */ public override object Execute(Reasoner r, Unifier un, ITerm[] args) { CheckArguments(args); StringBuilder sb = new StringBuilder(); foreach (ITerm term in args) { if (!term.IsString()) { continue; } IStringTerm st = (IStringTerm)term; MatchCollection matcher = rx.Matches(st.GetString()); int last = 0; var userBlock = new List <string>(); foreach (Match item in matcher) { //matcher.groups string sVar = item.Groups[0].Value; sVar = sVar.Substring(2, sVar.Length - 1); try { ITerm t = null; if (sVar.StartsWith("_") && sVar.Length > 1) { t = new UnnamedVar(int.Parse(sVar.Substring(1))); } else { t = AsSyntax.AsSyntax.ParseTerm(sVar); } t = t.CApply(un); //Hacer Regex.Replace(sb, t.IsString() ?....) serría una opción para hacerlo más compacto pero no sabemos //matcher.appendReplacement(sb, t.IsString() ? ((IStringTerm)t).GetString() : t.ToString()); if (sVar.Trim().Length > 0) { userBlock.Add(sVar); //No sabemos si esto está bien: el primer Append es para copiar el trozo //no matcheado y el segundo para el trozo que sí sb.Append(st.GetString().Substring(last, item.Index - last)); sb.Append(t.IsString() ? ((IStringTerm)t).GetString() : t.ToString()); } last = item.Index + item.Length; } catch (ParseException pe) { //matcher.appendReplacement(sb, "#{" + sVar + "}"); //Creemos que esto es para añadir el trocito que falta (va a estar mal seguro) sb.Append("#{" + sVar + "}"); } } //matcher.appendTail(sb); sb.Append(st.GetString().Substring(last));//Aquí hay que añadir lo que falta de la cadena original que no matchea } if (args[args.Length - 1].IsVar()) { IStringTerm stRes = new StringTermImpl(sb.ToString()); return(un.Unifies(stRes, args[args.Length - 1])); } else { //r.GetLogger().Info(sb.ToString()); return(true); } }
public void FindDesireAndDrop(Reasoner rs, Literal l, Unifier un) { Trigger g = new Trigger(TEOperator.add, TEType.achieve, l); Circumstance C = rs.GetCircumstance(); Unifier bak = un.Clone(); IEnumerator <Intention> itinit = C.GetRunningIntentionsPlusAtomic(); while (itinit.MoveNext()) { Intention i = itinit.Current; if (DropDesire(i, g, rs, un) > 1) { C.DropRunningIntention(i); un = bak.Clone(); } } // dropping the current intention? DropDesire(C.GetSelectedIntention(), g, rs, un); un = bak.Clone(); //dropping G in Events IEnumerator <Event> ie = C.GetEventsPlusAtomic(); while (ie.MoveNext()) { Event e = ie.Current; //Test in the intention Intention i = e.GetIntention(); int r = DropDesire(i, g, rs, un); if (r > 0) { C.RemoveEvent(e); if (r == 1) { C.ResumeIntention(i); } un = bak.Clone(); } else { //Test in the event Trigger t = e.GetTrigger(); if (i != Intention.emptyInt && !i.IsFinished()) { t = t.Capply(i.Peek().GetUnif()); } if (un.Unifies(g, t)) { DropDesireInEvent(rs, e, i); un = bak.Clone(); } } } //dropping G in Pending Events foreach (string ek in C.GetPendingEvents().Keys) { //Test in the intention Event e = C.GetPendingEvents()[ek]; Intention i = e.GetIntention(); int r = DropDesire(i, g, rs, un); if (r > 0) { C.RemovePendingEvent(ek); if (r == 1) { C.ResumeIntention(i); } un = bak.Clone(); } else { //test in the event Trigger t = e.GetTrigger(); if (i != Intention.emptyInt && !i.IsFinished()) { t = t.Capply(i.Peek().GetUnif()); } if (un.Unifies(g, t)) { DropDesireInEvent(rs, e, i); un = bak.Clone(); } } } //Dropping from pending Actions foreach (ExecuteAction a in C.GetPendingActions().Values) { Intention i = a.GetIntention(); int r = DropDesire(i, g, rs, un); if (r > 0) //i was changed { C.RemovePendingAction(i.GetID()); // remove i from PA if (r == 1) // i must continue running { C.ResumeIntention(i); // and put the intention back in I } // if r > 1, the event was generated and i will be back soon un = bak.Clone(); } } //Dropping from pending intentions foreach (Intention i in C.GetPendingIntentions().Values) { int r = DropDesire(i, g, rs, un); if (r > 0) { C.RemovePendingIntention(i.GetID()); if (r == 1) { C.ResumeIntention(i); } un = bak.Clone(); } } }
public MyRunnable2(Circumstance c, Intention si, string sEvt, bool dropped, bool stopByTimeout, Trigger te, ILogicalFormula formula, ITerm elapsedTimeTerm, Reasoner rs, Unifier un, long startTime) { this.c = c; this.si = si; this.sEvt = sEvt; this.dropped = dropped; this.stopByTimeout = stopByTimeout; this.te = te; this.formula = formula; this.elapsedTimeTerm = elapsedTimeTerm; this.rs = rs; this.un = un; this.startTime = startTime; }
public void Setup() { factory = new TypeFactory(); un = new Unifier(factory); }
public override ITerm[] PrepareArguments(Literal body, Unifier un) { ns = body.GetNS(); return(base.PrepareArguments(body, un)); }
override public ITerm[] PrepareArguments(Literal body, Unifier un) { return(body.GetTermsArray()); }
public override object Execute(Reasoner reasoner, Unifier un, ITerm[] args) { CheckArguments(args); FindDesireAndDrop(reasoner, (Literal)args[0], un); return(true); }
public IdConstant(EvaluationContext ctx, Unifier u) { this.ctx = ctx; this.unifier = u; }
/****** Checks *******/ /* * Returns true only if this term contains the variable t (or unifies with the variable term t?). * t - The variable term * u - The unifier */ public virtual bool HasVar(VarTerm t, Unifier u) { return(false); }
public IdConstant(EvaluationContext ctx, Unifier u, DecompilerEventListener listener) { this.ctx = ctx; this.unifier = u; this.listener = listener; }
public void Setup() { factory = new TypeFactory(); un = new Unifier(factory, null); }
/** * returns all unifications for intentions with some goal */ public static IEnumerator <Unifier> AllIntentions(Circumstance C, Literal l, ITerm intAsTerm, Unifier un) { Trigger g = new Trigger(TEOperator.add, TEType.achieve, l); return(new EnumeratorImpl(C, un, g, intAsTerm)); }
public override object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); return(args[0].IsGround()); }
public TypeGetTypeMethodThunkCache(TypeDesc owningTypeForThunks) { _owningTypeForThunks = owningTypeForThunks; _cache = new Unifier(this); }
/// <summary> /// Finds the minimal elements, in the partial order induced by unification, of the partial model facts. /// The number of minimal elements gives a lower bound on the number of distinct facts that must appear in an valid model. /// </summary> private void BuildPartialModelLowerBounds() { //// Step 1. Bin facts by head symbol. Term pattern; LinkedList <Term> gbin; Map <Term, MutableTuple <bool> > ngbin; var grdBins = new Map <Symbol, LinkedList <Term> >(Symbol.Compare); //// A term maps to true if it is deleted from the bin. var ngBins = new Map <Symbol, Map <Term, MutableTuple <bool> > >(Symbol.Compare); foreach (var f in Facts.Facts) { pattern = MkPattern(f); if (pattern == f) { Contract.Assert(pattern.Groundness == Groundness.Ground); if (!grdBins.TryFindValue(f.Symbol, out gbin)) { gbin = new LinkedList <Term>(); grdBins.Add(f.Symbol, gbin); } gbin.AddLast(f); } else { Contract.Assert(pattern.Groundness == Groundness.Variable); if (!ngBins.TryFindValue(f.Symbol, out ngbin)) { ngbin = new Map <Term, MutableTuple <bool> >(Term.Compare); ngBins.Add(f.Symbol, ngbin); } if (!ngbin.ContainsKey(pattern)) { ngbin.Add(pattern, new MutableTuple <bool>(false)); } } } //// Step 2. Any non-ground fact that matches with a ground fact is not minimal. Matcher matcher; foreach (var kv in ngBins) { ngbin = kv.Value; if (!grdBins.TryFindValue(kv.Key, out gbin)) { continue; } foreach (var p in ngbin) { matcher = new Matcher(p.Key); foreach (var g in gbin) { if (matcher.TryMatch(g)) { p.Value.Item1 = true; break; } } } PruneBin(ngbin); } //// Step 3. Iteratively compute the minimal elements until a fixpoint is reached. Term mgu; bool changed; LinkedList <Term> newGLBs; foreach (var kv in ngBins) { ngbin = kv.Value; changed = true; while (changed) { changed = false; newGLBs = null; foreach (var p1 in ngbin) { foreach (var p2 in ngbin.GetEnumerable(p1.Key)) { if (p1.Key == p2.Key) { continue; } else if (Unifier.IsUnifiable(p1.Key, p2.Key, x => MkNormalizedVar(Facts.Index, x), out mgu)) { if (mgu != p1.Key) { p1.Value.Item1 = true; } if (mgu != p2.Key) { p2.Value.Item1 = true; } if (mgu != p1.Key && mgu != p2.Key && !ngbin.ContainsKey(mgu)) { changed = true; if (newGLBs == null) { newGLBs = new LinkedList <Term>(); } newGLBs.AddLast(mgu); } } } } PruneBin(ngbin, newGLBs); } } //// Step 4. Create lower bounds Cardinality card; foreach (var kv in ngBins) { grdBins.TryFindValue(kv.Key, out gbin); if (gbin == null) { card = new Cardinality(new BigInteger(kv.Value.Count)); } else { card = new Cardinality(new BigInteger(kv.Value.Count) + new BigInteger(gbin.Count)); } AddConstraint(varMap[(UserSymbol)kv.Key].Item3 >= new CardCnst(card)); } foreach (var kv in grdBins) { if (ngBins.ContainsKey(kv.Key)) { continue; } AddConstraint(varMap[(UserSymbol)kv.Key].Item3 >= new CardCnst(new Cardinality(new BigInteger(kv.Value.Count)))); } }
override public object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); ts.GetAgent().Buf(ts.GetUserAgArch().Perceive()); return(true); }
public override object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); return(AllDesires(ts.GetCircumstance(), args[0] as Literal, args.Length == 2 ? args[1] : null, un)); }
public IdConstant(EvaluationContext ctx, Unifier u) { this.ctx = ctx; this.unifier = u; }
public void AddItemWithSize(Address addr, ImageMapItem itemNew) { if (!TryFindItem(addr, out var item)) { throw new ArgumentException(string.Format("Address {0} is not within the image range.", addr)); } // Do not split items with known data. if (!(item.DataType is UnknownType || item.DataType is CodeType)) { return; } long delta = addr - item.Address; Debug.Assert(delta >= 0, "Should have found an item at the supplied address."); if (delta > 0) { int afterOffset = (int)(delta + itemNew.Size); ImageMapItem itemAfter = null; if (item.Size > afterOffset) { itemAfter = new ImageMapItem { Address = addr + itemNew.Size, Size = (uint)(item.Size - afterOffset), DataType = ChopBefore(item.DataType, afterOffset), }; } item.Size = (uint)delta; item.DataType = ChopAfter(item.DataType, (int)delta); // Shrink the existing mofo. Items.Add(addr, itemNew); if (itemAfter != null) { Items.Add(itemAfter.Address, itemAfter); } } else { if (!(item.DataType is UnknownType) && !(item.DataType is CodeType)) { var u = new Unifier(); if (u.AreCompatible(item.DataType, itemNew.DataType)) { item.DataType = u.Unify(item.DataType, itemNew.DataType); } else { throw new NotSupportedException("Haven't handled this case yet."); } } Items.Remove(item.Address); item.Address += itemNew.Size; item.Size -= itemNew.Size; Items.Add(addr, itemNew); if (item.Size > 0 && !Items.ContainsKey(item.Address)) { Items.Add(item.Address, item); } } FireMapChanged(); }
public void CloneTest() { Unifier resultado = un.Clone(); Assert.AreEqual(un, resultado); }
[SetUp] // El @Before de Java public void SetUp() { un = new Unifier(); }
public override object Execute(Reasoner reasoner, Unifier un, ITerm[] args) { //Aqui tengo que coger, de alguna manera, la referencia a la lámpara y encender la luz return(base.Execute(reasoner, un, args)); }