private static void extractVarFromBasicGuards(KPsystem kpSystem, MType kpType, Module module, BasicGuard basicGuard) { Multiset ms = basicGuard.Multiset; NuSMV.RelationalOperator oper = SMVUtil.getRelationalOperator(basicGuard.Operator); Variable variable = null; foreach (var varName in ms.Objects) { if (!module.isVariableExist(varName)) { variable = new Variable(varName); int upperBound = ms[varName]; //if the guard requires a number greater, or greaterEqual, then it upperbound should be at least one number greater then, //the condition if (oper.Operator == NuSMV.RelationalOperator.GEQ || oper.Operator == NuSMV.RelationalOperator.GT) { upperBound = upperBound + 1; } variable.Type = new BoundInt(0, upperBound); setBoundIntType(kpSystem, kpType, module, variable); variable.Behaviour = VariableBehaviour.REWRITING; variable.Init = setOrUpdateInit(module, variable); module.Variables.Add(variable); } } }
internal static void addCaseLineToCurrentCopyCommVar(Variable orjVariable, Variable copyCommVar, KpCore.Rule rule, Module module, Module targetModule, int strategyIndex) { //for each variable generate a case line CaseLine caseLine = new CaseLine(); OperExp result = new OperExp(); int resultValue = 0; RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule; foreach (var target in rcr.TargetRhs.Values) { TargetedMultiset targetMultiSet = (TargetedMultiset)target; InstanceIdentifier targetType = (InstanceIdentifier)targetMultiSet.Target; if (targetModule.Type == targetType.Value) { Multiset ms = targetMultiSet.Multiset; foreach (var obj in ms.Objects) { if (obj.Equals(orjVariable.Name)) { resultValue += ms[obj]; } } } } result.Exp = copyCommVar.Name; if (resultValue != 0) { result.Oper.Value = MathOper.ADD; result.Result = new Expression(resultValue.ToString()); } caseLine.Result = result; caseLine.Rule = BRulesStandardVar.extractStandardRuleFromKPRule(rule, module, strategyIndex); ICondition sequenceCondition = BRulesStandardVar.getSequenceCondition(module, strategyIndex, rule.Id); ICondition targetBounds = getBoundCondition(copyCommVar, caseLine.Result); CompoundBoolExpression sequenceAndBound = new CompoundBoolExpression(sequenceCondition, BinaryOperator.AND, targetBounds); ICondition statusCondition = BRulesStandardVar.getTurnCondition(module, strategyIndex); CompoundBoolExpression statusAndSequence = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequenceAndBound); // _conn = to_c2 if (module.connectionToModuleExist(targetModule)) { BoolExp connEqInstance = new BoolExp(module.getConnectionToModule(targetModule).Name, NuSMV.RelationalOperator.EQUAL, SMVPreFix.getConnectedTo(targetModule.Instance)); caseLine.Rule.AddBoolExpression(connEqInstance, BinaryOperator.AND); } caseLine.Rule.AddBoolExpression(statusAndSequence, BinaryOperator.AND); caseLine.Rule.ID = rule.Id; if (copyCommVar.Next != null) { //if the case line has not added yet if (!ruleExist(copyCommVar.Next, caseLine)) { copyCommVar.Next.addCaseLine(caseLine); } } }
public void Add(Multiset m) { foreach (string o in m.Objects) { Add(o); } }
/// <summary> /// Translates parameter of MInstances to set of ParameterVars. Adds sync variable as parameter to all instances, /// i.e., modules. /// </summary> /// <param name="module"></param> /// <param name="type"></param> /// <param name="instance"></param> /// <returns></returns> public static HashSet <IVar> getInstanceParameters(Module module, MType type, MInstance instance) { HashSet <IVar> parameters = new HashSet <IVar>(); Multiset ms = instance.Multiset; bool paramExist = ms.Count > 0 || module.HasConnection; if (paramExist) { foreach (var param in ms.Objects) { ParameterVar parameter = new ParameterVar(); parameter.Name = param; parameter.Init = ms[param].ToString(); //get instance parameters parameters.Add(parameter); //set module parameters. module.Parameters.Add(parameter); } } //synch parameter ParameterVar synch = new ParameterVar(); synch.Behaviour = VariableBehaviour.CUSTOM; synch.Name = CustomVariables.SYNCH; synch.Init = CustomVariables.SYNCH; synch.IsParamPrefixed = false; //get instance parameters parameters.Add(synch); //set module parameters. module.Parameters.Add(synch); return(parameters); }
public void CreateFromIterable() { var multiset = new Multiset <string>(new[] { "foo", "bar", "foo" }); Assert.AreEqual(3, multiset.Count()); Assert.AreEqual(2, multiset.Count("foo")); }
public static string TranslateMultiset(Multiset ms) { StringBuilder buf = new StringBuilder(); if (ms.IsEmpty()) { buf.Append("{}"); } else { int i = 1; int count = ms.Count; foreach (KeyValuePair<string, int> kv in ms) { if (kv.Value > 1) { buf.Append(kv.Value); } buf.Append(kv.Key); if (i++ < count) { buf.Append(", "); } } } return buf.ToString(); }
public void SparqlSetDistinct2() { INode a = this._factory.CreateBlankNode(); INode b1 = (1).ToLiteral(this._factory); INode b2 = (2).ToLiteral(this._factory); Set x = new Set(); x.Add("a", a); x.Add("_:b", b1); Set y = new Set(); y.Add("a", a); y.Add("_:b", b2); Assert.NotEqual(x, y); Multiset data = new Multiset(); data.Add(x); data.Add(y); Assert.Equal(2, data.Count); Table table = new Table(data); Distinct distinct = new Distinct(table, true); //Distinct should yield two result and temporary variables should still //be present SparqlEvaluationContext context = new SparqlEvaluationContext(null, null); BaseMultiset results = distinct.Evaluate(context); Assert.Equal(2, results.Count); Assert.True(results.ContainsVariable("_:b")); }
private void registerSymbols(Multiset ms) { foreach (string symbol in ms.Objects) { a.AddSymbolIfNotExists(symbol); } }
private Multiset readMultiset(XPathNavigator parentNode, bool ignoreNullValues, Multiset x = null) { if (parentNode == null) { return(x); } if (x == null) { x = new Multiset(); } XPathNodeIterator mss = parentNode.SelectChildren("ms", String.Empty); while (mss.MoveNext()) { MTuple t = readTuple(mss.Current); if (t != null) { x.Add(t.Obj, t.Multiplicity, ignoreNullValues); } } return(x); }
public void SparqlSetDistinct1() { INode a = this._factory.CreateBlankNode(); INode b1 = (1).ToLiteral(this._factory); INode b2 = (2).ToLiteral(this._factory); Set x = new Set(); x.Add("a", a); x.Add("_:b", b1); Set y = new Set(); y.Add("a", a); y.Add("_:b", b2); Assert.AreNotEqual(x, y); Multiset data = new Multiset(); data.Add(x); data.Add(y); Assert.AreEqual(2, data.Count); Table table = new Table(data); Distinct distinct = new Distinct(table); //Distinct should yield a single result since temporary variables //are stripped SparqlEvaluationContext context = new SparqlEvaluationContext(null, null); BaseMultiset results = distinct.Evaluate(context); Assert.AreEqual(1, results.Count); Assert.IsFalse(results.ContainsVariable("_:b")); }
public ActiveInstance(IndexedMType itype, MInstance instance, KPsystem kp) : base(itype.Type, instance) { Buffer = new Multiset(); applicableRules = new List <Rule>(); this.kp = kp; IndexedMType = itype; }
/// <summary> /// Creates a new Multiset Handler /// </summary> /// <param name="mset">Multiset</param> public MultisetHandler(Multiset mset) { if (mset == null) { throw new ArgumentNullException("mset", "Multiset to load into cannot be null"); } this._mset = mset; }
public void Create() { var multiset = new Multiset <string> { { "foo", 2 }, "bar" }; Assert.AreEqual(3, multiset.Count()); Assert.AreEqual(2, multiset.Count("foo")); }
public void HasEntryMap() { var uut = new Multiset <string>(new[] { "foo", "bar", "foo", "bar" }); var expected = new Dictionary <string, int> { { "foo", 2 }, { "bar", 2 } }; CollectionAssert.AreEqual(expected, uut.EntryDictionary); }
public void RemovesAll() { var uut = new Multiset <string> { { "a", 5 } }; uut.RemoveAll("a"); Assert.AreEqual(0, uut.Count("a")); }
public Multiset <T> Intersection(Multiset <T> another) { Dictionary <T, int> newData = new Dictionary <T, int>(); foreach (T t in data.Keys.Intersect(another.data.Keys)) { newData[t] = Math.Min(data[t], another.data[t]); } return(new Multiset <T>(newData)); }
private void Guard(List <int> list, IGuard guard, bool negated = false) { if (guard is BasicGuard) { BasicGuard basicGuard = (BasicGuard)guard; int rel = 0; switch (basicGuard.Operator) { case RelationalOperator.LT: rel = 0; break; case RelationalOperator.LEQ: rel = 1; break; case RelationalOperator.EQUAL: rel = 2; break; case RelationalOperator.NOT_EQUAL: rel = 3; break; case RelationalOperator.GT: rel = 4; break; case RelationalOperator.GEQ: rel = 5; break; } if (negated) { rel += 8; } list.Add(rel); Multiset multiset = basicGuard.Multiset; string o = multiset.Objects.ToList()[0]; list.Add(objectsId[o]); list.Add(multiset[o]); } else if (guard is NegatedGuard) { NegatedGuard negatedGuard = (NegatedGuard)guard; Guard(list, negatedGuard.Operand, true); } else if (guard is CompoundGuard) { CompoundGuard compoundGuard = (CompoundGuard)guard; int op; if (compoundGuard.Operator == BinaryGuardOperator.AND) { op = 0; } else { op = 1; } Guard(list, compoundGuard.Lhs, negated); list.Add(op); Guard(list, compoundGuard.Rhs, negated); } }
public object VisitNonEmptyMultiset(KpLinguaParser.NonEmptyMultisetContext context) { var multiset = new Multiset(); foreach (var multisetAtomContext in context.multisetAtom()) { multiset.Add(multisetAtomContext.Accept(this) as Multiset); } return(multiset); }
public List <int> Multiset(Multiset m) { List <int> list = new List <int>(); foreach (string o in m.Objects) { list.Add(objectsId[o]); list.Add(m[o]); } list.Insert(0, list.Count / 2); return(list); }
public override ISet <string> tokens <T1>(IEnumerable <T1> iterable) { Multiset <string> tokens = HashMultiset.create(); int index = 0; foreach (object item in iterable) { tokens.add((index++).ToString()); tokens.addAll(fieldValues(item)); } //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: return(tokens.Where(token => tokens.count(token) == 1).collect(toImmutableSet())); }
private static int getTotalAmountOfDivisionVar(IVar variable, List <KpCore.Rule> divisionRules, List <InstanceBlueprint> result) { int totalAmount = 0; bool isFirstParent = true; string typeName = ""; foreach (InstanceBlueprint item in result) { typeName = item.Type.Name; int childValue = 0; int leftValue = 0; foreach (var divisionRule in divisionRules) { DivisionRule divRule = (DivisionRule)divisionRule; if (divRule.Rhs.Contains(item)) { Multiset leftOfRule = divRule.Lhs; foreach (var leftObj in leftOfRule.Objects) { if (leftObj.Equals(variable.Name)) { if (isFirstParent) { totalAmount = leftOfRule[leftObj]; isFirstParent = false; } leftValue = leftOfRule[leftObj]; } } } } Multiset ms = item.Multiset; foreach (var obj in ms.Objects) { if (obj.Equals(variable.Name)) { childValue = ms[obj]; } } totalAmount = totalAmount - leftValue + childValue; } //update max value. if (variable.Type is BoundInt) { (variable.Type as BoundInt).UpperBound = Math.Max((variable.Type as BoundInt).UpperBound, totalAmount); } return(totalAmount); }
private static void buildDivisionVariables(NuSMV.Module module, KPsystem kpSystem, KpCore.MType type, int strategyIndex, KpCore.Rule rule) { DivisionRule divisionRule = (DivisionRule)rule; foreach (var leftHRule in divisionRule.Lhs) { Variable variable = new Variable(leftHRule.Key); if (!module.Variables.Contains(variable)) { variable.Type = new BoundInt(0, setMax(kpSystem, type, module, variable)); variable.Behaviour = VariableBehaviour.REWRITING; variable.Init = setOrUpdateInit(module, variable); module.Variables.Add(variable); } else { //if variable exists then update the upperbound value. variable = (Variable)module.Variables.First(item => item.Name.Equals(leftHRule.Key)); } //add result of rule to caseline BRulesStandardVar.addCaseLineToStandardVariable(variable, rule, module, strategyIndex); } foreach (InstanceBlueprint compartment in divisionRule.Rhs) { MType compType = compartment.Type; if (type.Name.Equals(compType.Name)) { Multiset ms = compartment.Multiset; foreach (var obj in ms.Objects) { Variable variable = new Variable(obj); if (!module.Variables.Contains(variable)) { variable.Type = new BoundInt(0, setMax(kpSystem, compType, module, variable)); variable.Behaviour = VariableBehaviour.DIVISION; variable.Init = setOrUpdateInit(module, variable); module.Variables.Add(variable); } else { variable = (Variable)module.Variables.First(item => item.Name.Equals(obj)); variable.Behaviour = VariableBehaviour.DIVISION; } } } } // add rule to status variable BRulesCustomVar.addRuleToStatusVariable(rule, module, strategyIndex); }
private void WriteMultiset(Multiset m) { if (m == null) { return; } owt.Write("{ "); foreach (KeyValuePair <string, int> mv in m) { owt.Write(mv.Value); owt.Write(mv.Key); } owt.Write(" }"); }
/// <summary> /// Extracts boolean expression from a KP guard. In addition it adds module name as an identifier. /// </summary> /// <param name="sourceModule">module of guard</param> /// <param name="basicGuard"></param> /// <returns></returns> public static ICondition getBoolExpression(BasicGuard basicGuard) { Multiset ms = basicGuard.Multiset; NuSMV.RelationalOperator oper = SMVUtil.getRelationalOperator(basicGuard.Operator); BoolExp booleanExpression = new BoolExp(); foreach (var obj in ms.Objects) { booleanExpression.Left = new Expression(obj); booleanExpression.RelationalOperator = oper; booleanExpression.Right = new Expression(ms[obj].ToString()); } return(booleanExpression); }
public List <int> CalculateResults(int partyCount, Multiset <Int64> votingSituation, List <List <int> > preferenceOrders) { // For legacy purposes. var situation = new VotingSituation(); situation.PartyCount = partyCount; situation.LegacyPreferenceOrders = preferenceOrders; situation.Electorates.Add(new ElectorateVotes() { VoteCounts = votingSituation, Magnitude = 1 }); return(CalculateResults(situation)); }
private void writeMultiset(Multiset multiset) { owt.Write("{"); int i = 1; int count = multiset.Count; foreach (KeyValuePair <string, int> m in multiset) { owt.Write("\"" + m.Key + "\":" + m.Value); if (i++ < count) { owt.Write(", "); } } owt.Write("}"); }
public void Contains() { Multiset<string> multiset = new Multiset<string>(); multiset.Add("a"); Assert.IsTrue(multiset.Contains("a")); multiset.Add("a"); Assert.IsTrue(multiset.Contains("a")); multiset.Remove("a"); multiset.Remove("a"); Assert.IsFalse(multiset.Contains("a")); }
public void Contains() { Multiset <string> multiset = new Multiset <string>(); multiset.Add("a"); Assert.IsTrue(multiset.Contains("a")); multiset.Add("a"); Assert.IsTrue(multiset.Contains("a")); multiset.Remove("a"); multiset.Remove("a"); Assert.IsFalse(multiset.Contains("a")); }
private static void Multiset(ListNode<int> head) { Multiset<int> multiset = new Multiset<int>(); ListNode<int> previous = null; while(head != null) { if (multiset.Contains(head.Value)) previous.Next = head.Next; else { previous = head; multiset.Add(head.Value); } head = head.Next; } }
public object VisitMultisetAtom(KpLinguaParser.MultisetAtomContext context) { var multiset = default(Multiset); var multiplicityContext = context.Multiplicity(); var identifier = GetIdentifier(context.Identifier()); if (multiplicityContext != null) { multiset = new Multiset(identifier, GetMultiplicity(multiplicityContext)); } else { multiset = new Multiset(identifier); } return(multiset); }
public virtual BaseMultiset GetMultiset(IStore store) { var ms = new Multiset(Columns); foreach (var row in Rows) { var set = new Set(); for (int i = 0; i < Columns.Count; i++) { if (row[i] > 0) { set.Add(Columns[i], MakeNode(store, row[i])); } } ms.Add(set); } return(ms); }
/// <summary> /// Converts a Bindings Clause to a Multiset /// </summary> /// <returns></returns> public BaseMultiset ToMultiset() { if (this._vars.Any()) { Multiset m = new Multiset(); foreach (String var in this._vars) { m.AddVariable(var); } foreach (BindingTuple tuple in this._tuples) { m.Add(new Set(tuple)); } return(m); } else { return(new IdentityMultiset()); } }
public void Count() { Multiset<string> multiset = new Multiset<string>(); Assert.AreEqual(0, multiset.Count); multiset.Add("a"); multiset.Add("a"); Assert.AreEqual(2, multiset.Count); multiset.Remove("a"); Assert.AreEqual(1, multiset.Count); multiset.Add("b"); Assert.AreEqual(2, multiset.Count); multiset.Remove("a"); multiset.Remove("b"); Assert.AreEqual(0, multiset.Count); }
public static void Remove(Multiset<Pattern> excluded, Pattern remove) { excluded.Remove(remove); }
public static void Add(Multiset<Pattern> excluded, Pattern add) { excluded.Add(add); }