/// <summary>
/// [ REFS: '', DEREFS:]
/// </summary>
/// <param name="allProb"></param>
/// <param name="state"></param>
public double GetMaxProb(CUDDNode allProb, CUDDNode filter)
{
double result = 0;
CUDD.Ref(filter, reach);
CUDDNode newFilter = CUDD.Function.And(filter, reach);
if (newFilter.Equals(CUDD.ZERO))
{
result = double.MinValue;
}
else
{
CUDD.Ref(newFilter, allProb);
CUDDNode tmp = CUDD.Function.ITE(newFilter, allProb, CUDD.MinusInfinity());
result = CUDD.FindMax(tmp);
CUDD.Deref(tmp);
}
CUDD.Deref(newFilter);
return(result);
}
/// <summary>
/// [ REFS: 'result', DEREFS: 'guardDDs, commandDDs' ]
/// </summary>
/// <param name="guardDDs"></param>
/// <param name="commandDDs"></param>
/// <param name="currentAvailStartBit"></param>
/// <returns></returns>
private ComponentDDs CombineNondetCommands(List <CUDDNode> guardDDs, List <CUDDNode> commandDDs, int currentAvailStartBit)
{
ComponentDDs compDDs;
int i, j, maxChoices, numDDChoiceVarsUsed;
CUDDNode covered, transDD, overlaps, guardHasIChoices, tmp;
// create object to return result
compDDs = new ComponentDDs();
// use 'transDD' to build up MTBDD for transitions
transDD = CUDD.Constant(0);
// use 'covered' to track states covered by guards
covered = CUDD.Constant(0);
// find overlaps in guards by adding them all up
overlaps = CUDD.Constant(0);
for (i = 0; i < guardDDs.Count; i++)
{
CUDD.Ref(guardDDs[i]);
overlaps = CUDD.Function.Plus(overlaps, guardDDs[i]);
// compute bdd of all guards at same time
CUDD.Ref(guardDDs[i]);
covered = CUDD.Function.Or(covered, guardDDs[i]);
}
// find the max number of overlaps
// (i.e. max number of nondet. choices)
maxChoices = (int)Math.Round(CUDD.FindMax(overlaps));
// if all the guards were false, we're done already
if (maxChoices == 0)
{
compDDs.guards = covered;
compDDs.trans = transDD;
compDDs.min = currentAvailStartBit;
compDDs.max = currentAvailStartBit;
CUDD.Deref(overlaps);
CUDD.Deref(guardDDs, commandDDs);
return(compDDs);
}
// likewise, if there are no overlaps, it's also pretty easy
if (maxChoices == 1)
{
// add up dds for all commands
for (i = 0; i < guardDDs.Count; i++)
{
// add up transitions
CUDD.Ref(commandDDs[i]);
transDD = CUDD.Function.Plus(transDD, commandDDs[i]);
}
compDDs.guards = covered;
compDDs.trans = transDD;
compDDs.min = currentAvailStartBit;
compDDs.max = currentAvailStartBit;
CUDD.Deref(overlaps);
CUDD.Deref(guardDDs, commandDDs);
return(compDDs);
}
// otherwise, it's a bit more complicated...
// first, calculate how many dd vars will be needed
//the indexes of these bits are: (currentLastBitForChoice + 1), (currentLastBitForChoice + 2), ...
numDDChoiceVarsUsed = (int)Math.Ceiling(Math.Log(maxChoices, 2));
// select the variables we will use and put them in a JDDVars
if (currentAvailStartBit + numDDChoiceVarsUsed - 1 >= choiceVars.Count)
{
throw new Exception("Insufficient BDD variables allocated for nondeterminism - please report this as a bug. Thank you.");
}
CUDDVars varForThisChoice = new CUDDVars();
for (i = 0; i < numDDChoiceVarsUsed; i++)
{
varForThisChoice.AddVar(choiceVars[currentAvailStartBit + i]);
}
// for each i (i = 1 ... max number of nondet. choices)
for (i = 1; i <= maxChoices; i++)
{
// find sections of state space
// which have exactly i nondet. choices in this module
CUDD.Ref(overlaps);
guardHasIChoices = CUDD.Convert.Equals(overlaps, i);
// if there aren't any for this i, skip the iteration
if (guardHasIChoices.Equals(CUDD.ZERO))
{
CUDD.Deref(guardHasIChoices);
continue;
}
//store guards satisfying the guardHasIChoices, and classify them
List <CUDDNode> satisfiedGuards = new List <CUDDNode>();
//store the current number of commands satisfying the guard of the corresponding guard
List <int> numberOfChoicesAdded = new List <int>();
// go thru each command of the module...
for (j = 0; j < guardDDs.Count; j++)
{
// see if this command's guard overlaps with 'guardHasIChoices'
CUDD.Ref(guardDDs[j], guardHasIChoices);
tmp = CUDD.Function.And(guardDDs[j], guardHasIChoices);
// if it does...
if (!tmp.Equals(CUDD.ZERO))
{
//find guard Index
int guardIndex = -1;
int choiceIndexForThisCommand = 0;
for (int k = 0; k < satisfiedGuards.Count; k++)
{
if (satisfiedGuards[k].Equals(tmp))
{
guardIndex = k;
break;
}
}
//if guard exists, then use the index from numberOfChoicesAdded, and increase it
if (guardIndex >= 0)
{
choiceIndexForThisCommand = numberOfChoicesAdded[guardIndex];
numberOfChoicesAdded[guardIndex]++;
}
else
{
//if not exists, satisfiedGuards, numberOfChoicesAdded
satisfiedGuards.Add(tmp);
numberOfChoicesAdded.Add(1);
}
CUDD.Ref(commandDDs[j]);
tmp = CUDD.Function.Times(tmp, commandDDs[j]);
CUDDNode choiceIndexDD = CUDD.Matrix.SetVectorElement(CUDD.Constant(0), varForThisChoice, choiceIndexForThisCommand, 1);
CUDD.Ref(tmp);
transDD = CUDD.Function.Plus(transDD, CUDD.Function.Times(tmp, choiceIndexDD));
}
CUDD.Deref(tmp);
}
// take the i bits out of 'overlaps'
overlaps = CUDD.Function.Times(overlaps, CUDD.Function.Not(guardHasIChoices));
}
// store result
compDDs.guards = covered;
compDDs.trans = transDD;
compDDs.min = currentAvailStartBit;
compDDs.max = currentAvailStartBit + numDDChoiceVarsUsed;
CUDD.Deref(overlaps);
CUDD.Deref(guardDDs, commandDDs);
return(compDDs);
}