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);
}
