BranchingRule <TERM> Comp(TERM pathCond, BranchingRule <TERM> ruleA, int qB, Func <int, int, int> stateComposer, bool isFinal)
{
if (ruleA is SwitchRule <TERM> )
{
throw new NotImplementedException(ruleA.ToString());
}
var ite = ruleA as IteRule <TERM>;
if (ite != null)
{
var iteCondLifted = solver.ApplySubstitution(ite.Condition, A.RegVar, regVar_1);
var pathCond_T = (pathCond.Equals(solver.True) ? iteCondLifted : solver.MkAnd(pathCond, iteCondLifted));
var pathCond_F = (pathCond.Equals(solver.True) ? solver.MkNot(iteCondLifted) : solver.MkAnd(pathCond, solver.MkNot(iteCondLifted)));
var res_T = Comp(pathCond_T, ite.TrueCase, qB, stateComposer, isFinal);
var res_F = Comp(pathCond_F, ite.FalseCase, qB, stateComposer, isFinal);
if (res_T is UndefRule <TERM> && res_F is UndefRule <TERM> )
{
return(UndefRule <TERM> .Default);
}
var res = new IteRule <TERM>(iteCondLifted, res_T, res_F);
return(res);
}
else
{
var br = ruleA as BaseRule <TERM>;
if (br != null)
{
var yieldsFromALifted = br.Yields.ConvertAll(t => solver.ApplySubstitution(t, A.RegVar, regVar_1));
var inputsToB = ConsList <TERM> .Create(yieldsFromALifted);
var regALifted = solver.ApplySubstitution(br.Register, A.RegVar, regVar_1);
var res = this.EvalB(inputsToB, br.State, regALifted, pathCond, qB, regVar_2, stateComposer, Sequence <TERM> .Empty, isFinal);
return(res);
}
else
{
return(UndefRule <TERM> .Default);
}
}
}
public OrderedSet(params T[] ordered_list)
{
this.elements = ConsList <T> .Create(ordered_list);
this.count = (elements == null ? 0 : elements.Count());
}
OrderedSet(IEnumerable <T> ordered_list, int count)
{
this.elements = ConsList <T> .Create(ordered_list);
this.count = count;
}
public OrderedSet(IEnumerable <T> ordered_list)
{
this.elements = ConsList <T> .Create(ordered_list);
this.count = (elements == null ? 0 : elements.Count());
}
