public override string ToString()
{
switch (elems.Item2)
{
case CounterOp.EXIT:
return(LowerBoundCheck);
case CounterOp.SET0:
return(string.Format("{0}{1}0", SpecialCharacters.c(Counter.CounterId), SpecialCharacters.ASSIGN));
case CounterOp.EXIT_SET0:
return(string.Format("{2}{3}{0}{1}0", SpecialCharacters.c(Counter.CounterId), SpecialCharacters.ASSIGN, LowerBoundCheck, SpecialCharacters.IMPLIES));
case CounterOp.SET1:
return(string.Format("{0}{1}1", SpecialCharacters.c(Counter.CounterId), SpecialCharacters.ASSIGN));
case CounterOp.EXIT_SET1:
return(string.Format("{2}{3}{0}{1}1", SpecialCharacters.c(Counter.CounterId), SpecialCharacters.ASSIGN, LowerBoundCheck, SpecialCharacters.IMPLIES));
case CounterOp.INCR:
return(string.Format("{2}{3}{0}++", SpecialCharacters.c(Counter.CounterId), SpecialCharacters.ASSIGN, UpperBoundCheck, SpecialCharacters.IMPLIES));
default:
throw new NotImplementedException(elems.Item2.ToString());
}
}
public CsAutomaton(CsAlgebra <S> productAlgebra, Automaton <CsLabel <S> > aut, PowerSetStateBuilder stateBuilder, Dictionary <int, ICounter> countingStates, HashSet <int> origFinalStates) : base(aut)
{
this.stateBuilder = stateBuilder;
this.countingStates = countingStates;
this.origFinalStates = origFinalStates;
activeCounterMap = new Dictionary <int, HashSet <int> >();
finalCounterSet = new HashSet <int>();
counters = new ICounter[countingStates.Count];
foreach (var q in aut.States)
{
var q_set = new HashSet <int>();
activeCounterMap[q] = q_set;
foreach (var mem in stateBuilder.GetMembers(q))
{
if (countingStates.ContainsKey(mem))
{
var counterId = countingStates[mem].CounterId;
q_set.Add(counterId);
if (origFinalStates.Contains(mem))
{
finalCounterSet.Add(counterId);
}
counters[counterId] = countingStates[mem];
}
}
}
this.productAlgebra = productAlgebra;
stateDescr[InitialState] = SpecialCharacters.S(0);
}
public override string DescribeStartLabel()
{
if (IsCountingState(InitialState))
{
var c = countingStates[InitialState];
return(string.Format("{0}{1}0", SpecialCharacters.c(c.CounterId), SpecialCharacters.ASSIGN));
}
else
{
return("");
}
}
public override string ToString()
{
string s = "";
for (int i = 0; i < Length; i++)
{
if (this[i] != CsUpdate.NOOP)
{
s += string.Format("{0}({1});", this[i], SpecialCharacters.c(i));
}
}
return(s);
}
public string PrettyPrint(Tuple <Maybe <S>, Sequence <CounterOperation> > t)
{
if (t.Item1.IsSomething)
{
if (t.Item2.Length > 0)
{
char imp = SpecialCharacters.IMPLIES;
char prod = SpecialCharacters.MIDDOT;
if (t.Item2.Length == 1)
{
if (t.Item2[0].OperationKind == CounterOp.SET0 || t.Item2[0].OperationKind == CounterOp.SET1)
{
return(builder.solver.PrettyPrint(t.Item1.Element) + imp + t.Item2[0].ToString());
}
else
{
return(builder.solver.PrettyPrint(t.Item1.Element) + prod + t.Item2[0].ToString());
}
}
else
{
return(builder.solver.PrettyPrint(t.Item1.Element) + prod + t.Item2.ToString());
}
}
else
{
return(builder.solver.PrettyPrint(t.Item1.Element));
}
}
else
{
string s = "";
for (int i = 0; i < t.Item2.Length; i++)
{
if (t.Item2[i].OperationKind != CounterOp.EXIT)
{
throw new AutomataException(AutomataExceptionKind.InternalError);
}
if (t.Item2[i].Counter.LowerBound > 0)
{
if (s != "")
{
s += SpecialCharacters.AND;
}
s += string.Format("{0}{1}{2}", SpecialCharacters.c(t.Item2[i].Counter.CounterId), SpecialCharacters.GEQ, t.Item2[i].Counter.LowerBound);
}
}
return((s == "" ? SpecialCharacters.TOP.ToString() : s) + SpecialCharacters.CHECKMARK);
}
}
/// <summary>
/// Describe if the initial state is associuated with a counter, if so then set it to {0}
/// </summary>
public override string DescribeStartLabel()
{
var initcounters = activeCounterMap[InitialState].GetEnumerator();
if (initcounters.MoveNext())
{
var c = initcounters.Current;
return(string.Format("{0}={{0}}", SpecialCharacters.c(c)));
}
else
{
return("");
}
}
/// <summary>
/// Describe the state information, including original states if determinized, as well as counters.
/// </summary>
public override string DescribeState(int state)
{
string s;
if (!stateDescr.TryGetValue(state, out s))
{
s = SpecialCharacters.S(stateDescr.Count);
stateDescr[state] = s;
}
var mems = new List <int>(stateBuilder.GetMembers(state));
mems.Sort();
if (!__hidePowersets)
{
s += "\n" + "{";
foreach (var q in mems)
{
if (!s.EndsWith("{"))
{
s += ",";
}
s += SpecialCharacters.q(q);
}
s += "}";
}
var state_counters = GetCountersOfState(state);
var state_counters_list = new List <int>(state_counters);
state_counters_list.Sort();
foreach (var c in state_counters_list)
{
s += "\n";
s += "(" + SpecialCharacters.c(c) + ")";
//s += "(" + counters[c].LowerBound +
// SpecialCharacters.LEQ + SpecialCharacters.Cntr(c) + SpecialCharacters.LEQ + counters[c].UpperBound + ")";
if (finalCounterSet.Contains(c))
{
s += SpecialCharacters.XI_LOWERCASE + SpecialCharacters.ToSubscript(c);
s += SpecialCharacters.CHECKMARK;
}
}
return(s);
}
public override string ToString()
{
string s = "";
if (isAND)
{
for (int i = 0; i < Length; i++)
{
if (this[i] != CsCondition.TRUE)
{
if (s != "")
{
s += SpecialCharacters.AND;
}
s += string.Format("{0}({1})", this[i], SpecialCharacters.c(i));
}
}
if (s == "")
{
s = SpecialCharacters.TOP.ToString();
}
}
else
{
for (int i = 0; i < Length; i++)
{
if (this[i] != CsCondition.FALSE)
{
if (s != "")
{
s += SpecialCharacters.OR;
}
s += string.Format("{0}({1})", this[i], SpecialCharacters.c(i));
}
}
if (s == "")
{
s = SpecialCharacters.BOT.ToString();
}
}
return(s);
}
public override string DescribeState(int state)
{
string s;
if (__hideDerivativesInViewer)
{
s = SpecialCharacters.q(state);
}
else
{
s = stateMap[state].ToString();
}
if (countingStates != null)
{
if (IsFinalState(state) && IsCountingState(state))
{
s += "\n(";
var f = GetFinalStateCondition(state);
for (int i = 0; i < f.Length; i++)
{
if (i > 0)
{
s += SpecialCharacters.AND;
}
var op = f[i];
s += op.ToString();
}
s += ")" + SpecialCharacters.CHECKMARK;
}
else if (IsCountingState(state))
{
s += "\n(" + SpecialCharacters.c(countingStates[state].CounterId) + ")";
}
}
return(s);
}
/// <summary>
/// Produces 'q' with subscript i
/// </summary>
public static string q(int i)
{
return("q" + SpecialCharacters.ToSubscript(i));
}
public static string DescribeCondition <S>(CsAlgebra <S> algebra, CsCondition cond, int i)
{
string c = SpecialCharacters.c(i);
string canExit = SpecialCharacters.XI_LOWERCASE + SpecialCharacters.ToSubscript(i);
string canIncr = SpecialCharacters.IOTA_LOWERCASE + SpecialCharacters.ToSubscript(i);
char and = SpecialCharacters.AND;
char or = SpecialCharacters.OR;
char not = SpecialCharacters.NOT;
string empty = string.Format("{0}={1}", c, SpecialCharacters.EMPTYSET);
string nonempty = string.Format("{0}{1}{2}", c, SpecialCharacters.NEQ, SpecialCharacters.EMPTYSET);
string _true = SpecialCharacters.TOP.ToString();
string _false = SpecialCharacters.BOT.ToString();
switch (cond)
{
case CsCondition.TRUE:
return(_true);
case CsCondition.FALSE:
return(_false);
case CsCondition.EMPTY:
return(empty);
case CsCondition.NONEMPTY:
return(nonempty);
case CsCondition.LOW:
//return string.Format("{0}{2}{3}{4}max({0})<{1}", SpecialCharacters.Cntr(i), algebra.GetCounter(i).LowerBound, SpecialCharacters.NEQ, SpecialCharacters.EMPTYSET, SpecialCharacters.AND);
//return canIncr + and + not + canExit;
return(not + canExit);
case CsCondition.HIGH:
//return string.Format("{0}={{{1}}}", SpecialCharacters.Cntr(i), algebra.GetCounter(i).UpperBound);
//return not + canIncr + and + canExit;
return(not + canIncr);
case CsCondition.CANEXIT:
//return string.Format("{0}{1}{2}", SpecialCharacters.Cntr(i), SpecialCharacters.GEQ, algebra.GetCounter(i).LowerBound);
return(canExit);
case CsCondition.CANNOTEXIT:
//return string.Format("{0}{1}{2}", SpecialCharacters.Cntr(i), SpecialCharacters.NOTGEQ, algebra.GetCounter(i).LowerBound);
return(not + canExit);
case CsCondition.CANLOOP:
//return string.Format("{0}+1{1}{2}", SpecialCharacters.Cntr(i), SpecialCharacters.NEQ, SpecialCharacters.EMPTYSET);
//return string.Format("{0}x{1}{2}(x<{3})", SpecialCharacters.EXISTS, SpecialCharacters.IN, SpecialCharacters.Cntr(i), algebra.GetCounter(i).UpperBound);
return(canIncr);
case CsCondition.CANNOTLOOP:
//return string.Format("{0}+1{1}{2}", SpecialCharacters.Cntr(i), "=", SpecialCharacters.EMPTYSET);
//return string.Format("{0}x{1}{2}(x<{3})", SpecialCharacters.NOTEXISTS, SpecialCharacters.IN, SpecialCharacters.Cntr(i), algebra.GetCounter(i).UpperBound);
return(not + canIncr);
case CsCondition.MIDDLE:
//return string.Format("{2}{4}{5}{6}{0}{1}max({2})<{3}", algebra.GetCounter(i).LowerBound, SpecialCharacters.LEQ, SpecialCharacters.Cntr(i), algebra.GetCounter(i).UpperBound, SpecialCharacters.NEQ, SpecialCharacters.EMPTYSET, SpecialCharacters.AND);
return(canIncr + and + canExit);
#region these cases should not occur
case CsCondition.LOWorHIGH:
//return string.Format("({0}{1}{2})", DescribeCondition<S>(algebra, CsCondition.LOW, i), SpecialCharacters.OR, DescribeCondition<S>(algebra, CsCondition.HIGH, i));
return("(" + not + canIncr + or + not + canExit + ")");
case CsCondition.EMPTYorCANEXIT:
return("(" + empty + or + canExit + ")");
case CsCondition.EMPTYorCANLOOP:
return("(" + empty + or + canIncr + ")");
case CsCondition.EMPTYorHIGHorLOW:
return("(" + empty + or + not + canIncr + or + not + canExit + ")");
case CsCondition.EMPTYorMIDDLE:
return("(" + empty + or + canIncr + and + canExit + ")");
default:
throw new AutomataException(AutomataExceptionKind.UndefinedEnum);
#endregion
}
}
internal string ToString(bool debugmode)
{
if (debugmode)
{
return(ToString());
}
else
{
string s = "";
for (int i = 0; i < Length; i++)
{
string c = SpecialCharacters.c(i);
char assign = SpecialCharacters.ASSIGN;
char union = SpecialCharacters.UNION;
switch (this[i])
{
case CsUpdate.INCR:
{
s += c + "++";
break;
}
case CsUpdate.INCR0:
{
s += c + "++" + union + "{0}";
break;
}
case CsUpdate.INCR1:
{
s += c + "++" + union + "{1}";
break;
}
case CsUpdate.INCR01:
{
s += c + "++" + union + "{0,1}";
break;
}
case CsUpdate.SET0:
{
s += c + assign + "{0}";
break;
}
case CsUpdate.SET1:
{
s += c + assign + "{1}";
break;
}
case CsUpdate.SET01:
{
s += c + assign + "{0,1}";
break;
}
default:
{
break;
}
}
}
return(s);
}
}