/// <summary>
/// Return the rol-vars vector of the product of matrix and vector
/// [ REFS: 'result', DEREFS: '' ]
/// </summary>
/// <param name="matrix">Matrix of rol * col vars</param>
/// <param name="vector">Vector of rol vars</param>
/// <returns></returns>
public static CUDDNode MatrixMultiplyVector(CUDDNode matrix, CUDDNode vector, CUDDVars allRowVars, CUDDVars allColVars)
{
//Return matrix * vector
CUDD.Ref(vector);
CUDDNode temp = Variable.SwapVariables(vector, allRowVars, allColVars);
CUDD.Ref(matrix);
CUDDNode result = MatrixMultiply(matrix, temp, allColVars, BOULDER);
return result;
}
public static CUDDNode NondetReachReward(CUDDNode trans, CUDDNode reach, CUDDNode stateReward, CUDDNode transReward, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVars, CUDDNode goal, CUDDNode infReward, CUDDNode maybeReward, bool min)
{
DateTime startTime = DateTime.Now;
int numberOfIterations = 0;
CUDDNode a, allReward, newNondetMask, sol, tmp;
// filter out rows (goal states and infinity states) from matrix
CUDD.Ref(trans, maybeReward);
a = CUDD.Function.Times(trans, maybeReward);
// also remove goal and infinity states from state rewards vector
CUDD.Ref(stateReward, maybeReward);
CUDDNode tempStateReward = CUDD.Function.Times(stateReward, maybeReward);
// multiply transition rewards by transition probs and sum rows
// (note also filters out unwanted states at the same time)
CUDD.Ref(transReward, a);
CUDDNode tempTransReward = CUDD.Function.Times(transReward, a);
tempTransReward = CUDD.Abstract.SumAbstract(tempTransReward, allColVars);
// combine state and transition rewards
allReward = CUDD.Function.Plus(tempStateReward, tempTransReward);
// need to change mask because rewards are not necessarily in the range 0..1
CUDD.Ref(nondetMask);
newNondetMask = CUDD.Function.ITE(nondetMask, CUDD.PlusInfinity(), CUDD.Constant(0));
// initial solution is infinity in 'inf' states, zero elsewhere
// note: ok to do this because cudd matrix-multiply (and other ops)
// treat 0 * inf as 0, unlike in IEEE 754 rules
CUDD.Ref(infReward);
sol = CUDD.Function.ITE(infReward, CUDD.PlusInfinity(), CUDD.Constant(0));
while (true)
{
numberOfIterations++;
tmp = CUDD.Matrix.MatrixMultiplyVector(a, sol, allRowVars, allColVars);
// add rewards
CUDD.Ref(allReward);
tmp = CUDD.Function.Plus(tmp, allReward);
if (min)
{
CUDD.Ref(newNondetMask);
tmp = CUDD.Function.Maximum(tmp, newNondetMask);
tmp = CUDD.Abstract.MinAbstract(tmp, nondetVars);
}
else
{
tmp = CUDD.Abstract.MaxAbstract(tmp, nondetVars);
}
CUDD.Ref(infReward);
tmp = CUDD.Function.ITE(infReward, CUDD.PlusInfinity(), tmp);
if (CUDD.IsEqual(tmp, sol))
{
CUDD.Deref(tmp);
break;
}
CUDD.Deref(sol);
sol = tmp;
}
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("NondetReachReward: " + numberOfIterations + " iterations in " + runningTime + " seconds");
//
CUDD.Deref(a, allReward, newNondetMask);
return(sol);
}
public static CUDDNode NondetInstReward(CUDDNode trans, CUDDNode stateReward, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVars, int bound, bool min, CUDDNode init)
{
DateTime startTime = DateTime.Now;
CUDDNode newNondetMask, sol, tmp;
CUDD.Ref(nondetMask);
newNondetMask = CUDD.Function.ITE(nondetMask, CUDD.PlusInfinity(), CUDD.Constant(0));
CUDD.Ref(stateReward);
sol = stateReward;
for (int i = 0; i < bound; i++)
{
tmp = CUDD.Matrix.MatrixMultiplyVector(trans, sol, allRowVars, allColVars);
if (min)
{
CUDD.Ref(newNondetMask);
tmp = CUDD.Function.Maximum(tmp, newNondetMask);
tmp = CUDD.Abstract.MinAbstract(tmp, nondetVars);
}
else
{
tmp = CUDD.Abstract.MaxAbstract(tmp, nondetVars);
}
//
CUDD.Deref(sol);
sol = tmp;
}
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("NondetInstReward: " + bound + " iterations in " + runningTime + " seconds");
//
CUDD.Deref(newNondetMask);
return(sol);
}
/// <summary>
/// // sets element in 3d matrix dd
/// [ REFS: 'result', DEREFS: 'dd' ]
/// </summary>
public static CUDDNode Set3DMatrixElement(CUDDNode dd, CUDDVars rVars, CUDDVars cVars, CUDDVars lVars, int rIndex, int cIndex, int lIndex, double value)
{
return(new CUDDNode(PlatformInvoke.DD_Set3DMatrixElement(manager, dd.Ptr, rVars.GetArrayPointer(), rVars.GetNumVars(), cVars.GetArrayPointer(), cVars.GetNumVars(), lVars.GetArrayPointer(), lVars.GetNumVars(), rIndex, cIndex, lIndex, value)));
}
/// <summary>
/// Convert ADD to 0-1 ADD based on the interval [lower, upper]
/// [ REFS: 'result', DEREFS: dd ]
/// </summary>
public static CUDDNode Interval(CUDDNode dd, double lower, double upper)
{
return new CUDDNode(PlatformInvoke.DD_Interval(manager, dd.Ptr, lower, upper));
}
/// <summary>
/// Sets element in matrix dd and return value.
/// Note that this is a function, not a procedure
/// [ REFS: 'result', DEREFS: 'dd' ]
/// </summary>
public static CUDDNode SetMatrixElement(CUDDNode dd, CUDDVars rVars, CUDDVars cVars, int rIndex, int cIndex, double value)
{
return new CUDDNode(PlatformInvoke.DD_SetMatrixElement(manager, dd.Ptr, rVars.GetArrayPointer(), rVars.GetNumVars(), cVars.GetArrayPointer(), cVars.GetNumVars(), rIndex, cIndex, value));
}
/// <summary>
/// Returns matrix multiplication of matrices dd1 and dd2
/// [Calculates the product of two matrices represented as ADDs.]
/// Description [Calculates the product of two matrices, A and B,
/// represented as ADDs. This procedure implements the quasiring multiplication
/// algorithm. A is assumed to depend on variables x (rows) and z
/// (columns). B is assumed to depend on variables z (rows) and y
/// (columns). The product of A and B then depends on x (rows) and y
/// (columns). Only the z variables have to be explicitly identified;
/// they are the "summation" variables. Returns a pointer to the
/// result if successful; NULL otherwise.]
/// [ REFS: 'result', DEREFS: 'dd1, dd2' ]
/// </summary>
/// <param name="dd1"></param>
/// <param name="dd2"></param>
/// <param name="vars">variable are shared by both dd1, dd2. Normally dd1 row + column, dd2 only column</param>
/// <param name="method"></param>
/// <returns></returns>
public static CUDDNode MatrixMultiply(CUDDNode dd1, CUDDNode dd2, CUDDVars vars, int method)
{
return new CUDDNode(PlatformInvoke.DD_MatrixMultiply(manager, dd1.Ptr, dd2.Ptr, vars.GetArrayPointer(), vars.GetNumVars(), method));
}
/// <summary>
/// Returns transpose of matrix dd
/// [ REFS: 'result', DEREFS: 'dd' ]
/// </summary>
public static CUDDNode Transpose(CUDDNode dd, CUDDVars rVars, CUDDVars cVars)
{
return new CUDDNode(PlatformInvoke.DD_Transpose(manager, dd.Ptr, rVars.GetArrayPointer(), cVars.GetArrayPointer(), rVars.GetNumVars()));
}
/// <summary>
/// Return variable values after the If statement is executed based on resultBefore
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
ExpressionBDDEncoding tempResult1 = new ExpressionBDDEncoding();
ExpressionBDDEncoding tempResult2 = new ExpressionBDDEncoding();
List <List <int> > updatedVariablesBefore = new List <List <int> >();
for (int index = 0; index < resultBefore.Count(); index++)
{
updatedVariablesBefore.Add(model.GetColSupportedVars(resultBefore.GuardDDs[index]));
}
ExpressionBDDEncoding conditionDD = this.Condition.TranslateBoolExpToBDD(model);
List <List <int> > usedVariablesInCondition = new List <List <int> >();
for (int index = 0; index < conditionDD.Count(); index++)
{
usedVariablesInCondition.Add(model.GetRowSupportedVars(conditionDD.GuardDDs[index]));
}
for (int j1 = 0; j1 < resultBefore.Count(); j1++)
{
for (int j2 = 0; j2 < conditionDD.Count(); j2++)
{
CUDDNode condition = conditionDD.GuardDDs[j2];
CUDD.Ref(condition);
foreach (int index in usedVariablesInCondition[j2])
{
if (updatedVariablesBefore[j1].Contains(index))
{
condition = CUDD.Variable.SwapVariables(condition, model.GetRowVars(index), model.GetColVars(index));
}
}
CUDD.Ref(resultBefore.GuardDDs[j1]);
CUDDNode transition = CUDD.Function.And(resultBefore.GuardDDs[j1], condition);
tempResult1.AddNodeToGuard(transition);
}
}
//the condition is not always false (a = 1; if(a > 1))
if (tempResult1.Count() > 0)
{
tempResult1 = this.ThenPart.TranslateStatementToBDD(tempResult1, model);
}
//
tempResult2 = new ExpressionBDDEncoding();
for (int j1 = 0; j1 < resultBefore.Count(); j1++)
{
for (int j2 = 0; j2 < conditionDD.Count(); j2++)
{
CUDDNode condition = conditionDD.GuardDDs[j2];
CUDD.Ref(condition);
condition = CUDD.Function.Not(condition);
foreach (int index in usedVariablesInCondition[j2])
{
if (updatedVariablesBefore[j1].Contains(index))
{
condition = CUDD.Variable.SwapVariables(condition, model.GetRowVars(index), model.GetColVars(index));
}
}
CUDD.Ref(resultBefore.GuardDDs[j1]);
CUDDNode transition = CUDD.Function.And(resultBefore.GuardDDs[j1], condition);
tempResult2.AddNodeToGuard(transition);
}
}
if (this.ElsePart != null && tempResult2.Count() > 0)
{
tempResult2 = this.ElsePart.TranslateStatementToBDD(tempResult2, model);
}
conditionDD.DeRef();
//Combine
if (tempResult1.Count() == 0 && tempResult2.Count() == 0)//condition always false, no else part
{
return(resultBefore);
}
else if (tempResult1.Count() == 0 && tempResult2.Count() > 0)//condition always false, having else part
{
resultBefore.DeRef();
return(tempResult2);
}
else
{
resultBefore.DeRef();
tempResult1.AddNodeToGuard(tempResult2.GuardDDs);
return(tempResult1);
}
}
public static List <Tuple <CUDDNode, Tuple <Predicate, bool>[]> > GetCondEffectList(this PlanningParser.EffectContext context,
CUDDNode currentConditionNode, IReadOnlyDictionary <string, Predicate> predicateDict,
StringDictionary assignment)
{
var result = new List <Tuple <CUDDNode, Tuple <Predicate, bool>[]> >();
foreach (var cEffectContext in context.cEffect())
{
var condEffect = cEffectContext.GetCondEffectList(currentConditionNode, predicateDict, assignment);
result.AddRange(condEffect);
}
return(result);
}
public void Test1Test()
{
var sb = new StringBuilder();
string varX = "x";
string varY = "y";
//Set number of action names, 2 for a, b
Model.NUMBER_OF_EVENT = 3;
Model.MAX_NUMBER_EVENT_PARAMETERS = 0;
BDDEncoder encoder = new BDDEncoder();
encoder.model.AddGlobalVar(varX, 0, 10);
encoder.model.AddGlobalVar(varY, 0, 10);
SymbolicLTS lts = new SymbolicLTS();
State state1 = lts.AddState();
State state2 = lts.AddState();
State state3 = lts.AddState();
State state4 = lts.AddState();
lts.InitialState = state1;
var primitiveApplication1 = new Assignment(varX, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varX),
new IntConstant(1)));
var primitiveApplication2 = new Assignment(varY, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varY),
new IntConstant(4)));
/*
*
* for (int i = 0; i < exps.Count; i++)
* {
* //Update eventParameterVariables[i] = exps[i]
* //Don't need to update exps because later after synchronization, not updated variable keeps the same value
* update = new Sequence(update, new Assignment(model.eventParameterVariables[i], exps[i]));
* }
*/
var primitiveApplication = new Sequence(primitiveApplication1,
primitiveApplication2);
/*PrimitiveApplication.CombineProgramBlock(
* primitiveApplication1,
* primitiveApplication2);*/
logger.Info(primitiveApplication);
Transition trans1 = new Transition(new Event("a"), null,
primitiveApplication,
state1,
state2);
Expression assignment =
new Assignment(varX, new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varX),
new IntConstant(2)));
logger.Info("Assignments: " + assignment);
var secAssignment =
new Assignment(varY,
new PrimitiveApplication(PrimitiveApplication.PLUS,
new Variable(varY), new WildConstant()));
Transition trans2 = new Transition(new Event("b"), null,
primitiveApplication,
state2,
state3);
Transition trans3 = new Transition(new Event("c"), null,
primitiveApplication,
state3,
state4);
lts.AddTransition(trans1);
lts.AddTransition(trans2);
lts.AddTransition(trans3);
AutomataBDD systemBDD = lts.Encode(encoder);
//Variable x is initialised to 1
systemBDD.initExpression = new PrimitiveApplication(PrimitiveApplication.AND,
systemBDD.initExpression,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(varX), new IntConstant(1)));
systemBDD.initExpression = new PrimitiveApplication(PrimitiveApplication.AND,
systemBDD.initExpression,
new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(varY), new IntConstant(1)));
CUDDNode initDD = CUDD.Function.Or(systemBDD.initExpression.TranslateBoolExpToBDD(encoder.model).GuardDDs);
logger.Info("init: " + systemBDD.initExpression);
var u = 1;
for (; u < 2; u++)
{
logger.Info($"U is {u}");
//Define 2 goals
Expression goal1 = new PrimitiveApplication(PrimitiveApplication.EQUAL,
new Variable(varX), new IntConstant(3));
goal1 = new PrimitiveApplication(PrimitiveApplication.AND, goal1, new PrimitiveApplication(PrimitiveApplication.EQUAL, new Variable(varY), new IntConstant(9)));
//Encode 2 goals to BDD
CUDDNode goal1DD = CUDD.Function.Or(goal1.TranslateBoolExpToBDD(encoder.model).GuardDDs);
logger.Info("Goal: " + goal1);
List <CUDDNode> path = new List <CUDDNode>();
bool reach1 = encoder.model.PathForward(initDD, goal1DD, new List <List <CUDDNode> >()
{
systemBDD.transitionBDD
}, path, true);
if (reach1)
{
sb.AppendLine("goal1 is reachable");
foreach (var cuddNode in path)
{
encoder.model.PrintAllVariableValue(cuddNode);
logger.Info("after");
CUDD.Print.PrintMinterm(cuddNode);
// CUDD.Print.PrintBDDTree(path);
int valueOfX = encoder.model.GetRowVarValue(cuddNode, varX);
sb.AppendLine(varX + " = " + valueOfX);
int valueOfY = encoder.model.GetRowVarValue(cuddNode, varY);
sb.AppendLine(varY + " = " + valueOfY);
}
}
else
{
sb.AppendLine("goal1 is unreachable");
}
path.Clear();
}
/*
* bool reach2 = encoder.model.PathForward(initDD, goal2DD, new List<List<CUDDNode>>() { systemBDD.transitionBDD }, path, true);
* if (reach2)
* {
* sb.AppendLine("goal2 is reachable");
* foreach (var cuddNode in path)
* {
* int valueOfX = encoder.model.GetRowVarValue(cuddNode, varX);
* sb.AppendLine(varX + " = " + valueOfX);
* }
* }
* else
* {
* sb.AppendLine("goal2 is unreachable");
* }
*/
logger.Info(sb);
encoder.model.Close();
}
/// <summary>
/// Returns matrix multiplication of matrices dd1 and dd2
/// [ REFS: 'result', DEREFS: 'dd1, dd2' ]
/// </summary>
public static CUDDNode MatrixMultiply(CUDDNode dd1, CUDDNode dd2, CUDDVars vars, int method)
{
return(new CUDDNode(PlatformInvoke.DD_MatrixMultiply(manager, dd1.Ptr, dd2.Ptr, vars.GetArrayPointer(), vars.GetNumVars(), method)));
}
/// <summary>
/// Returns transpose of matrix dd
/// [ REFS: 'result', DEREFS: 'dd' ]
/// </summary>
public static CUDDNode Transpose(CUDDNode dd, CUDDVars rVars, CUDDVars cVars)
{
return(new CUDDNode(PlatformInvoke.DD_Transpose(manager, dd.Ptr, rVars.GetArrayPointer(), cVars.GetArrayPointer(), rVars.GetNumVars())));
}
/// <summary>
/// Get element in vector dd
/// [ REFS: 'none', DEREFS: 'none' ]
/// </summary>
public static double GetVectorElement(CUDDNode dd, CUDDVars vars, int index)
{
return(PlatformInvoke.DD_GetVectorElement(manager, dd.Ptr, vars.GetArrayPointer(), vars.GetNumVars(), index));
}
/// <summary>
/// Return Pmax(b1 U b2) = 0
/// </summary>
/// <param name="trans01"></param>
/// <param name="reach"></param>
/// <param name="allRowVars"></param>
/// <param name="allColVars"></param>
/// <param name="nondetvars"></param>
/// <param name="b1"></param>
/// <param name="b2"></param>
/// <returns></returns>
public static CUDDNode Prob0A(CUDDNode trans01, CUDDNode reach, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetvars, CUDDNode b1, CUDDNode b2)
{
DateTime startTime = DateTime.Now;
int numberOfIterations = 0;
CUDD.Ref(b2);
CUDDNode sol = b2;
while (true)
{
numberOfIterations++;
CUDD.Ref(sol, trans01);
CUDDNode tmp = CUDD.Function.And(CUDD.Variable.SwapVariables(sol, allRowVars, allColVars), trans01);
tmp = CUDD.Abstract.ThereExists(tmp, allColVars);
tmp = CUDD.Abstract.ThereExists(tmp, nondetvars);
CUDD.Ref(b1);
tmp = CUDD.Function.And(b1, tmp);
CUDD.Ref(b2);
tmp = CUDD.Function.Or(b2, tmp);
if (tmp.Equals(sol))
{
CUDD.Deref(tmp);
break;
}
CUDD.Deref(sol);
sol = tmp;
}
CUDD.Ref(reach);
sol = CUDD.Function.And(reach, CUDD.Function.Not(sol));
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("Prob0A: " + numberOfIterations + " iterations in " + runningTime + " seconds");
return(sol);
}
/// <summary>
/// Set the value of i.th element in vector. i is allowed to be negative. -1 is the last element.
/// Note that this is a function, not a procedure
/// [ REFS: 'result', DEREFS: 'dd' ]
/// </summary>
public static CUDDNode SetVectorElement(CUDDNode dd, CUDDVars vars, int index, double value)
{
return new CUDDNode(PlatformInvoke.DD_SetVectorElement(manager, dd.Ptr, vars.GetArrayPointer(), vars.GetNumVars(), index, value));
}
/// <summary>
/// Encode this assignment in a sequence of statements. Return variable values after this assignment based on the current value in resultBefore
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
ExpressionBDDEncoding newUpdate = this.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding tempResult = new ExpressionBDDEncoding();
List <List <int> > updatedVariablesInNewUpdate = new List <List <int> >();
for (int index = 0; index < newUpdate.Count(); index++)
{
updatedVariablesInNewUpdate.Add(model.GetColSupportedVars(newUpdate.GuardDDs[index]));
}
List <List <int> > usedVariableInNewUpdate = new List <List <int> >();
for (int index = 0; index < newUpdate.Count(); index++)
{
usedVariableInNewUpdate.Add(model.GetRowSupportedVars(newUpdate.GuardDDs[index]));
}
List <List <int> > updatedVariablesBefore = new List <List <int> >();
for (int index = 0; index < resultBefore.Count(); index++)
{
updatedVariablesBefore.Add(model.GetColSupportedVars(resultBefore.GuardDDs[index]));
}
for (int j1 = 0; j1 < resultBefore.Count(); j1++)
{
for (int j2 = 0; j2 < newUpdate.Count(); j2++)
{
//a variable is already updated, now is updated again and it also apprears in the value expression
if (Assignment.IsComplexUpdate(updatedVariablesBefore[j1], updatedVariablesInNewUpdate[j2], usedVariableInNewUpdate[j2]))
{
model.CreateTemporaryVar();
Expression newUpdate1;
Expression newUpdate2;
PropertyAssignment assignment = this as PropertyAssignment;
newUpdate1 = new Assignment(Model.TEMPORARY_VARIABLE, this.RightHandExpression);
newUpdate2 = new PropertyAssignment(this.RecordExpression, this.PropertyExpression, new Variable(Model.TEMPORARY_VARIABLE));
resultBefore.Ref();
ExpressionBDDEncoding tempResult1 = newUpdate1.TranslateStatementToBDD(resultBefore, model);
ExpressionBDDEncoding tempResult2 = newUpdate2.TranslateStatementToBDD(tempResult1, model);
//Remove the temporary variable from transition
for (int i = 0; i < tempResult2.Count(); i++)
{
tempResult2.GuardDDs[i] = CUDD.Abstract.ThereExists(tempResult2.GuardDDs[i], model.GetRowVars(model.GetVarIndex(Model.TEMPORARY_VARIABLE)));
tempResult2.GuardDDs[i] = CUDD.Abstract.ThereExists(tempResult2.GuardDDs[i], model.GetColVars(model.GetVarIndex(Model.TEMPORARY_VARIABLE)));
tempResult.AddNodeToGuard(tempResult2.GuardDDs[i]);
}
}
else
{
//swap row, col updated variable in result in the new update command expression
CUDDNode update2 = newUpdate.GuardDDs[j2];
CUDD.Ref(update2);
foreach (int index in updatedVariablesBefore[j1])
{
if (usedVariableInNewUpdate[j2].Contains(index))
{
update2 = CUDD.Variable.SwapVariables(update2, model.GetColVars(index), model.GetRowVars(index));
}
}
//Restrict updated variable in new update of the old update
CUDDNode update1 = resultBefore.GuardDDs[j1];
CUDD.Ref(update1);
foreach (int index in updatedVariablesInNewUpdate[j2])
{
if (updatedVariablesBefore[j1].Contains(index))
{
update1 = CUDD.Abstract.ThereExists(update1, model.GetColVars(index));
}
}
CUDDNode transition = CUDD.Function.And(update1, update2);
tempResult.AddNodeToGuard(transition);
}
}
}
resultBefore.DeRef();
newUpdate.DeRef();
return(tempResult);
}
/// <summary>
/// Get element in vector dd
/// [ REFS: 'none', DEREFS: 'none' ]
/// </summary>
public static double GetVectorElement(CUDDNode dd, CUDDVars vars, int index)
{
return PlatformInvoke.DD_GetVectorElement(manager, dd.Ptr, vars.GetArrayPointer(), vars.GetNumVars(), index);
}
/// <summary>
/// return Pmax(b1 U b2) = 1
/// </summary>
/// <param name="trans01"></param>
/// <param name="reach"></param>
/// <param name="allRowVars"></param>
/// <param name="allColVars"></param>
/// <param name="nondetVars"></param>
/// <param name="b1"></param>
/// <param name="b2"></param>
/// <param name="no"></param>
/// <returns></returns>
public static CUDDNode Prob1E(CUDDNode trans01, CUDDNode reach, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVars, CUDDNode b1, CUDDNode b2, CUDDNode no)
{
DateTime startTime = DateTime.Now;
int numberOfIterations = 0;
CUDD.Ref(reach, no);
CUDDNode u = CUDD.Function.And(reach, CUDD.Function.Not(no));
bool uDone = false;
while (!uDone)
{
CUDDNode v = CUDD.Constant(0);
bool vDone = false;
while (!vDone)
{
numberOfIterations++;
CUDD.Ref(u);
CUDDNode tmp = CUDD.Variable.SwapVariables(u, allRowVars, allColVars);
CUDD.Ref(trans01);
tmp = CUDD.Abstract.ForAll(CUDD.Function.Implies(trans01, tmp), allColVars);
CUDD.Ref(v);
CUDDNode tmp2 = CUDD.Variable.SwapVariables(v, allRowVars, allColVars);
CUDD.Ref(trans01);
tmp2 = CUDD.Abstract.ThereExists(CUDD.Function.And(tmp2, trans01), allColVars);
tmp = CUDD.Function.And(tmp, tmp2);
tmp = CUDD.Abstract.ThereExists(tmp, nondetVars);
CUDD.Ref(b1);
tmp = CUDD.Function.And(b1, tmp);
CUDD.Ref(b2);
tmp = CUDD.Function.Or(b2, tmp);
if (tmp.Equals(v))
{
vDone = true;
}
CUDD.Deref(v);
v = tmp;
}
if (v == u)
{
uDone = true;
}
CUDD.Deref(u);
u = v;
}
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("Prob1E: " + numberOfIterations + " iterations in " + runningTime + " seconds");
return(u);
}
/// <summary>
/// Return Pmin(phi1 U phi2) = 1
/// </summary>
/// <param name="trans01"></param>
/// <param name="reach"></param>
/// <param name="nondetMask"></param>
/// <param name="allRowVars"></param>
/// <param name="allColVars"></param>
/// <param name="nondetVar"></param>
/// <param name="no"></param>
/// <param name="b2"></param>
/// <returns></returns>
public static CUDDNode Prob1A(CUDDNode trans01, CUDDNode reach, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVar, CUDDNode no, CUDDNode b2)
{
DateTime startTime = DateTime.Now;
int numberOfIterations = 0;
CUDD.Ref(reach, no);
CUDDNode notNo = CUDD.Function.And(reach, CUDD.Function.Not(no));
CUDD.Ref(b2, notNo);
CUDDNode sol = CUDD.Function.Or(b2, notNo);
while (true)
{
numberOfIterations++;
CUDD.Ref(sol);
CUDDNode tmp = CUDD.Variable.SwapVariables(sol, allRowVars, allColVars);
CUDD.Ref(trans01);
tmp = CUDD.Abstract.ForAll(CUDD.Function.Implies(trans01, tmp), allColVars);
CUDD.Ref(nondetMask);
tmp = CUDD.Function.Or(tmp, nondetMask);
tmp = CUDD.Abstract.ForAll(tmp, nondetVar);
CUDD.Ref(notNo);
tmp = CUDD.Function.And(notNo, tmp);
CUDD.Ref(b2);
tmp = CUDD.Function.Or(b2, tmp);
if (tmp.Equals(sol))
{
CUDD.Deref(tmp);
break;
}
CUDD.Deref(sol);
sol = tmp;
}
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("Prob1A: " + numberOfIterations + " iterations in " + runningTime + " seconds");
//
CUDD.Deref(notNo);
return(sol);
}
public static CUDDNode NondetBoundedUntil(CUDDNode trans, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVars, CUDDNode yes, CUDDNode maybe, int bound, bool min)
{
DateTime startTime = DateTime.Now;
CUDDNode a, sol, tmp;
CUDD.Ref(trans, maybe);
a = CUDD.Function.Times(trans, maybe);
CUDD.Ref(yes);
sol = yes;
for (int i = 0; i < bound; i++)
{
tmp = CUDD.Matrix.MatrixMultiplyVector(a, sol, allRowVars, allColVars);
if (min)
{
CUDD.Ref(nondetMask);
tmp = CUDD.Function.Maximum(tmp, nondetMask);
tmp = CUDD.Abstract.MinAbstract(tmp, nondetVars);
}
else
{
tmp = CUDD.Abstract.MaxAbstract(tmp, nondetVars);
}
CUDD.Ref(yes);
tmp = CUDD.Function.Maximum(tmp, yes);
CUDD.Deref(sol);
sol = tmp;
}
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("NondetBoundedUntil: " + bound + " iterations in " + runningTime + " seconds");
//
CUDD.Deref(a);
return(sol);
}
/// <summary>
/// Convert ADD to 0-1 ADD based on the interval (threshold, +inf)
/// [ REFS: 'result', DEREFS: dd ]
/// </summary>
public static CUDDNode GreaterThan(CUDDNode dd, double threshold)
{
return new CUDDNode(PlatformInvoke.DD_GreaterThan(manager, dd.Ptr, threshold));
}
public static CUDDNode NondetUntil(CUDDNode trans, CUDDNode nondetMask, CUDDVars allRowVars, CUDDVars allColVars, CUDDVars nondetVars, CUDDNode yes, CUDDNode maybe, bool min)
{
DateTime startTime = DateTime.Now;
int numberOfIterations = 0;
CUDDNode a, sol, tmp;
CUDD.Ref(trans, maybe);
a = CUDD.Function.Times(trans, maybe);
CUDD.Ref(yes);
sol = yes;
while (true)
{
numberOfIterations++;
tmp = CUDD.Matrix.MatrixMultiplyVector(a, sol, allRowVars, allColVars);
if (min)
{
CUDD.Ref(nondetMask);
tmp = CUDD.Function.Maximum(tmp, nondetMask);
tmp = CUDD.Abstract.MinAbstract(tmp, nondetVars);
}
else
{
tmp = CUDD.Abstract.MaxAbstract(tmp, nondetVars);
}
CUDD.Ref(yes);
tmp = CUDD.Function.Maximum(tmp, yes);
//check convergence
if (CUDD.IsEqual(tmp, sol))
{
CUDD.Deref(tmp);
break;
}
CUDD.Deref(sol);
sol = tmp;
}
DateTime endTime = DateTime.Now;
double runningTime = (endTime - startTime).TotalSeconds;
Debug.WriteLine("NondetUntil: " + numberOfIterations + " iterations in " + runningTime + " seconds");
//
CUDD.Deref(a);
return(sol);
}
/// <summary>
/// Convert ADD to 0-1 ADD based on the interval (-inf, threshold]
/// [ REFS: 'result', DEREFS: dd ]
/// </summary>
public static CUDDNode LessThanEquals(CUDDNode dd, double threshold)
{
return new CUDDNode(PlatformInvoke.DD_LessThanEquals(manager, dd.Ptr, threshold));
}
/// <summary>
/// Set the value of i.th element in vector. i is allowed to be negative. -1 is the last element.
/// [ REFS: 'result', DEREFS: 'dd' ]
/// </summary>
public static CUDDNode SetVectorElement(CUDDNode dd, CUDDVars vars, int index, double value)
{
return(new CUDDNode(PlatformInvoke.DD_SetVectorElement(manager, dd.Ptr, vars.GetArrayPointer(), vars.GetNumVars(), index, value)));
}
