private ExpressionBDDEncoding TranslateLogicalBinaryExpression(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandTranslation1 = this.Argument1.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding operandTranslation2 = this.Argument2.TranslateBoolExpToBDD(model);
List <CUDDNode> operand1 = (operandTranslation1.Count() > 0)? operandTranslation1.GuardDDs: new List <CUDDNode>();
List <CUDDNode> operand2 = (operandTranslation2.Count() > 0) ? operandTranslation2.GuardDDs : new List <CUDDNode>();
switch (this.Operator)
{
case AND:
result.GuardDDs = CUDD.Function.And(operand1, operand2);
break;
case OR:
result.GuardDDs.AddRange(operand1);
result.GuardDDs.AddRange(operand2);
break;
default:
throw new Exception("Unknown operator");
}
return(result);
}
/// <summary>
/// Encode this assignment as a single statement
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding variableBddEncoding = new PrimitiveApplication(PrimitiveApplication.ARRAYPRIME, this.RecordExpression,
this.PropertyExpression).TranslateIntExpToBDD(model);
ExpressionBDDEncoding valueBddEncoding = this.RightHandExpression.TranslateIntExpToBDD(model);
for (int i = 0; i < variableBddEncoding.Count(); i++)
{
for (int j = 0; j < valueBddEncoding.Count(); j++)
{
CUDD.Ref(variableBddEncoding.GuardDDs[i], valueBddEncoding.GuardDDs[j]);
CUDDNode guardDD = CUDD.Function.And(variableBddEncoding.GuardDDs[i], valueBddEncoding.GuardDDs[j]);
if (guardDD.Equals(CUDD.ZERO))
{
CUDD.Deref(guardDD);
continue;
}
CUDD.Ref(variableBddEncoding.ExpressionDDs[i], valueBddEncoding.ExpressionDDs[j]);
CUDDNode assignmentDD = CUDD.Function.Equal(variableBddEncoding.ExpressionDDs[i], valueBddEncoding.ExpressionDDs[j]);
guardDD = CUDD.Function.And(guardDD, assignmentDD);
result.AddNodeToGuard(guardDD);
}
}
//remove unused expression
variableBddEncoding.DeRef();
valueBddEncoding.DeRef();
return result;
}
/// <summary>
/// Encode arithmetic expression whose returned value is integer
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
if (IsBinaryExpression() && IsBinaryNumericalExpression())
{
return(TranslateNumericalBinaryExpression(model));
}
else if (IsBinaryExpression() && IsArrayExpression())
{
return(TranslateArrayExpression(model));
}
else if (!IsBinaryExpression() && this.Operator == NEGATIVE)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandBddEncoding = this.Argument1.TranslateIntExpToBDD(model);
for (int i = 0; i < operandBddEncoding.Count(); i++)
{
result.GuardDDs.Add(operandBddEncoding.GuardDDs[i]);
result.ExpressionDDs.Add(CUDD.Function.Minus(CUDD.Constant(0), operandBddEncoding.ExpressionDDs[i]));
}
return(result);
}
else
{
ExpressionBDDEncoding operandBddEncoding = this.Argument1.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
for (int i = 0; i < operandBddEncoding.Count(); i++)
{
result.ExpressionDDs.Add(operandBddEncoding.GuardDDs[i]);
result.GuardDDs.Add(CUDD.Constant(1));
}
return(result);
}
}
/// <summary>
/// Only 1 expression of constant, guard ONE
/// </summary>
public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
return(result);
}
/// <summary>
/// Can support array of array
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private ExpressionBDDEncoding TranslateArrayExpression(Model model)
{
if (this.Argument2 is IntConstant)
{
int indexValue = ((IntConstant)this.Argument2).Value;
if (Operator == ARRAY)
{
return(new Variable(this.Argument1 + Model.NAME_SEPERATOR + indexValue).TranslateIntExpToBDD(model));
}
else
{
return(new VariablePrime(this.Argument1 + Model.NAME_SEPERATOR + indexValue).TranslateIntExpToBDD(model));
}
}
ExpressionBDDEncoding indexBddEncoding = this.Argument2.TranslateIntExpToBDD(model);
//Get the array range
int min = model.GetArrayRange(this.Argument1.ExpressionID)[0];
int max = model.GetArrayRange(this.Argument1.ExpressionID)[1];
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
//a[i]
for (int i = min; i <= max; i++)
{
for (int j = 0; j < indexBddEncoding.Count(); j++)
{
//index = i & guard of index
CUDD.Ref(indexBddEncoding.ExpressionDDs[j], indexBddEncoding.GuardDDs[j]);
CUDDNode guard = CUDD.Function.And(CUDD.Function.Equal(indexBddEncoding.ExpressionDDs[j], CUDD.Constant(i)),
indexBddEncoding.GuardDDs[j]);
if (guard != CUDD.ZERO)
{
//a[i]
result.GuardDDs.Add(guard);
Expression arrayExpression;
if (Operator == ARRAY)
{
arrayExpression = new Variable(this.Argument1.ExpressionID + Model.NAME_SEPERATOR + i);
}
else
{
arrayExpression = new VariablePrime(this.Argument1.ExpressionID + Model.NAME_SEPERATOR + i);
}
result.ExpressionDDs.Add(arrayExpression.TranslateIntExpToBDD(model).ExpressionDDs[0]);
}
else
{
CUDD.Deref(guard);
}
}
}
//dereference later because 2 loops above
indexBddEncoding.DeRef();
return(result);
}
//public override string GetID()
//{
// return Value.ToString();
//}
/// <summary>
/// Return the encoding of the integer value
/// </summary>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
result.ExpressionDDs.Add(CUDD.Constant(Value));
return result;
}
/// <summary>
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
resultBefore = this.FirstPart.TranslateStatementToBDD(resultBefore, model);
resultBefore = this.SecondPart.TranslateStatementToBDD(resultBefore, model);
return(resultBefore);
}
/// <summary>
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
resultBefore = this.FirstPart.TranslateStatementToBDD(resultBefore, model);
resultBefore = this.SecondPart.TranslateStatementToBDD(resultBefore, model);
return resultBefore;
}
/// <summary>
/// Encode boolean expression
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
if (IsBinaryExpression())
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
if (IsBinaryLogicalExpression())
{
result = TranslateLogicalBinaryExpression(model);
}
else if (IsRelationalExpression())
{
result = TranslateRelationalBinaryExpression(model);
}
return(result);
}
else if (this.Operator == NOT)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandBddEncoding = this.Argument1.TranslateBoolExpToBDD(model);
result.AddNodeToGuard(CUDD.Function.Not(operandBddEncoding.GuardDDs));
return(result);
}
//
throw new Exception("Unknown operator");
}
/// <summary>
/// Return only guards for complete boolean expression, no expression
/// Use this when we want to encode a single assignment or the assignment does not depend other assignments.
/// </summary>
public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding variableBddEncoding = new VariablePrime(this.LeftHandSide).TranslateIntExpToBDD(model);
ExpressionBDDEncoding valueBddEncoding = this.RightHandSide.TranslateIntExpToBDD(model);
for (int i = 0; i < variableBddEncoding.Count(); i++)
{
for (int j = 0; j < valueBddEncoding.Count(); j++)
{
CUDD.Ref(variableBddEncoding.GuardDDs[i], valueBddEncoding.GuardDDs[j]);
CUDDNode guardDD = CUDD.Function.And(variableBddEncoding.GuardDDs[i], valueBddEncoding.GuardDDs[j]);
if (guardDD.Equals(CUDD.ZERO))
{
CUDD.Deref(guardDD);
continue;
}
CUDD.Ref(variableBddEncoding.ExpressionDDs[i], valueBddEncoding.ExpressionDDs[j]);
CUDDNode assignmentDD = CUDD.Function.Equal(variableBddEncoding.ExpressionDDs[i], valueBddEncoding.ExpressionDDs[j]);
guardDD = CUDD.Function.And(guardDD, assignmentDD);
result.AddNodeToGuard(guardDD);
}
}
//remove unused expression
variableBddEncoding.DeRef();
valueBddEncoding.DeRef();
return(result);
}
/// <summary>
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
CUDDNode conditionDD = CUDD.Function.Or(this.Test.TranslateBoolExpToBDD(model).GuardDDs);
do
{
ExpressionBDDEncoding tempResult = 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]));
}
List <int> usedVariablesInCondition = model.GetRowSupportedVars(conditionDD);
for (int j1 = 0; j1 < resultBefore.Count(); j1++)
{
foreach (int index in usedVariablesInCondition)
{
if (updatedVariablesBefore[j1].Contains(index))
{
conditionDD = CUDD.Variable.SwapVariables(conditionDD, model.GetRowVars(index), model.GetColVars(index));
}
}
//Add configuration making the While condition true
CUDD.Ref(resultBefore.GuardDDs[j1], conditionDD);
CUDDNode transition = CUDD.Function.And(resultBefore.GuardDDs[j1], conditionDD);
tempResult.AddNodeToGuard(transition);
//Add configuration making the While condition false
CUDD.Ref(resultBefore.GuardDDs[j1], conditionDD);
CUDDNode falseTransition = CUDD.Function.And(resultBefore.GuardDDs[j1], CUDD.Function.Not(conditionDD));
result.AddNodeToGuard(falseTransition);
}
//There is no any configuration making the While condition true
if (tempResult.Count() > 0)
{
resultBefore.DeRef();
resultBefore = this.Body.TranslateStatementToBDD(tempResult, model);
}
else
{
break;
}
} while (true);
resultBefore.DeRef();
return(result);
}
/// <summary>
/// A sequence, containing some statement, must be encoded in TranslateStatementToBDD mode
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
result = TranslateStatementToBDD(result, model);
return result;
}
/// <summary>
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
CUDDNode conditionDD = CUDD.Function.Or(this.Test.TranslateBoolExpToBDD(model).GuardDDs);
do
{
ExpressionBDDEncoding tempResult = 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]));
}
List<int> usedVariablesInCondition = model.GetRowSupportedVars(conditionDD);
for (int j1 = 0; j1 < resultBefore.Count(); j1++)
{
foreach (int index in usedVariablesInCondition)
{
if (updatedVariablesBefore[j1].Contains(index))
{
conditionDD = CUDD.Variable.SwapVariables(conditionDD, model.GetRowVars(index), model.GetColVars(index));
}
}
//Add configuration making the While condition true
CUDD.Ref(resultBefore.GuardDDs[j1], conditionDD);
CUDDNode transition = CUDD.Function.And(resultBefore.GuardDDs[j1], conditionDD);
tempResult.AddNodeToGuard(transition);
//Add configuration making the While condition false
CUDD.Ref(resultBefore.GuardDDs[j1], conditionDD);
CUDDNode falseTransition = CUDD.Function.And(resultBefore.GuardDDs[j1], CUDD.Function.Not(conditionDD));
result.AddNodeToGuard(falseTransition);
}
//There is no any configuration making the While condition true
if (tempResult.Count() > 0)
{
resultBefore.DeRef();
resultBefore = this.Body.TranslateStatementToBDD(tempResult, model);
}
else
{
break;
}
} while (true);
resultBefore.DeRef();
return result;
}
/// <summary>
/// Used as a special statement which does nothing
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
if (Value)
{
return(resultBefore);
}
else
{
return(new ExpressionBDDEncoding());
}
}
/// <summary>
/// Return variable expression
/// </summary>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
int variableIndex = model.GetVarIndex(this.expressionID);
CUDDNode varDD = model.variableEncoding[variableIndex];
CUDD.Ref(varDD);
result.ExpressionDDs.Add(varDD);
return result;
}
///
/// <summary>
/// Use when the boolen constant is used as expression: a = true
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
string channelName = Arguments[0].ToString();
string countChannelVariable = Model.GetCountVarChannel(channelName);
string topChannelVariable = Model.GetTopVarChannel(channelName);
switch (MethodName)
{
case Constants.cfull:
Expression isFull = Expression.EQ(new Variable(countChannelVariable), new IntConstant(model.mapChannelToSize[channelName]));
ExpressionBDDEncoding isFullTemp = isFull.TranslateBoolExpToBDD(model);
isFullTemp.ExpressionDDs = new List <CUDDNode>(isFullTemp.GuardDDs);
isFullTemp.GuardDDs = new List <CUDDNode>()
{
CUDD.Constant(1)
};
return(isFullTemp);
case Constants.cempty:
Expression isEmpty = Expression.EQ(new Variable(countChannelVariable), new IntConstant(0));
ExpressionBDDEncoding isEmptyTemp = isEmpty.TranslateBoolExpToBDD(model);
isEmptyTemp.ExpressionDDs = new List <CUDDNode>(isEmptyTemp.GuardDDs);
isEmptyTemp.GuardDDs = new List <CUDDNode>()
{
CUDD.Constant(1)
};
return(isEmptyTemp);
case Constants.ccount:
return(new Variable(countChannelVariable).TranslateIntExpToBDD(model));
case Constants.csize:
return(new IntConstant(model.mapChannelToSize[channelName]).TranslateIntExpToBDD(model));
case Constants.cpeek:
//(top_a - count_a) % L
Expression popedElementPosition = new PrimitiveApplication(PrimitiveApplication.MOD,
Expression.MINUS(new Variable(topChannelVariable), new Variable(countChannelVariable)),
new IntConstant(model.mapChannelToSize[channelName]));
//a[top_a - count_a % L][i]
return(new PrimitiveApplication(PrimitiveApplication.ARRAY, new Variable(channelName), Expression.TIMES(
popedElementPosition,
new IntConstant(Model.MAX_MESSAGE_LENGTH))
).TranslateIntExpToBDD(model));
}
throw new Exception("Static call can not be encoded in BDD");
}
///
/// <summary>
/// Use when the boolen constant is used as expression: a = true
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
if (Value)
{
result.ExpressionDDs.Add(CUDD.Constant(1));
}
else
{
result.ExpressionDDs.Add(CUDD.Constant(0));
}
return(result);
}
/// <summary>
/// Return variable expression
/// </summary>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
result.GuardDDs.Add(CUDD.Constant(1));
int variableIndex = model.GetVarIndex(this.expressionID);
CUDDNode varDD = model.variableEncoding[variableIndex];
CUDD.Ref(varDD);
result.ExpressionDDs.Add(varDD);
return(result);
}
/// <summary>
/// Create a new local variable
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
//Create new local variable if not exists
if (!model.ContainsVar(this.Variable))
{
model.AddLocalVar(this.Variable, Model.BDD_INT_LOWER_BOUND, Model.BDD_INT_UPPER_BOUND);
}
//If there is an initialization then do it based on the resultBefore
if (this.RightHandExpression == null)
{
return resultBefore;
}
else
{
return (new Assignment(this.Variable, RightHandExpression)).TranslateStatementToBDD(resultBefore, model);
}
}
/// <summary>
/// Create a new local variable
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
//Create new local variable if not exists
if (!model.ContainsVar(this.Variable))
{
model.AddLocalVar(this.Variable, Model.BDD_INT_LOWER_BOUND, Model.BDD_INT_UPPER_BOUND);
}
//If there is an initialization then do it based on the resultBefore
if (this.RightHandExpression == null)
{
return(resultBefore);
}
else
{
return((new Assignment(this.Variable, RightHandExpression)).TranslateStatementToBDD(resultBefore, model));
}
}
/// <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);
}
}
private ExpressionBDDEncoding TranslateRelationalBinaryExpression(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandTranslation1 = this.Argument1.TranslateIntExpToBDD(model);
ExpressionBDDEncoding operandTranslation2 = this.Argument2.TranslateIntExpToBDD(model);
CUDDNode guardOfResult = CUDD.Constant(0);
for (int i = 0; i < operandTranslation1.Count(); i++)
{
for (int j = 0; j < operandTranslation2.Count(); j++)
{
CUDD.Ref(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
CUDDNode guardDD = CUDD.Function.And(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
if (guardDD.Equals(CUDD.ZERO))
{
CUDD.Deref(guardDD);
continue;
}
CUDDNode expressionDD;
CUDD.Ref(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
switch (this.Operator)
{
case EQUAL:
expressionDD = CUDD.Function.Equal(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case NOT_EQUAL:
expressionDD = CUDD.Function.NotEqual(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case GREATER:
expressionDD = CUDD.Function.Greater(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case GREATER_EQUAL:
expressionDD = CUDD.Function.GreaterEqual(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case LESS:
expressionDD = CUDD.Function.Less(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case LESS_EQUAL:
expressionDD = CUDD.Function.LessEqual(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
default:
throw new Exception("Unknown operator");
}
guardDD = CUDD.Function.And(guardDD, expressionDD);
if (guardDD.Equals(CUDD.ZERO))
{
CUDD.Deref(guardDD);
continue;
}
guardOfResult = CUDD.Function.Or(guardOfResult, guardDD);
}
}
result.AddNodeToGuard(guardOfResult);
//Remove all old guard, expression
operandTranslation1.DeRef();
operandTranslation2.DeRef();
return(result);
}
/// <summary>
/// Encode boolean expression
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateBoolExpToBDD(Model model)
{
if (IsBinaryExpression())
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
if (IsBinaryLogicalExpression())
{
result = TranslateLogicalBinaryExpression(model);
}
else if (IsRelationalExpression())
{
result = TranslateRelationalBinaryExpression(model);
}
return result;
}
else if (this.Operator == NOT)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandBddEncoding = this.Argument1.TranslateBoolExpToBDD(model);
result.AddNodeToGuard(CUDD.Function.Not(operandBddEncoding.GuardDDs));
return result;
}
//
throw new Exception("Unknown operator");
}
/// <summary>
/// Return the variable values after the assignment based on the current variable values 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 (IsComplexUpdate(updatedVariablesBefore[j1], updatedVariablesInNewUpdate[j2], usedVariableInNewUpdate[j2]))
{
model.CreateTemporaryVar();
Expression newUpdate1;
Expression newUpdate2;
newUpdate1 = new Assignment(Model.TEMPORARY_VARIABLE, this.RightHandSide);
newUpdate2 = new Assignment(this.LeftHandSide, new Variable(Model.TEMPORARY_VARIABLE));
resultBefore.Ref();
ExpressionBDDEncoding tempResult1 = newUpdate1.TranslateStatementToBDD(resultBefore, model);
ExpressionBDDEncoding tempResult2 = newUpdate2.TranslateStatementToBDD(tempResult1, model);
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>
/// Encode arithmetic expression whose returned value is integer
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public override ExpressionBDDEncoding TranslateIntExpToBDD(Model model)
{
if (IsBinaryExpression() && IsBinaryNumericalExpression())
{
return TranslateNumericalBinaryExpression(model);
}
else if (IsBinaryExpression() && IsArrayExpression())
{
return TranslateArrayExpression(model);
}
else if (!IsBinaryExpression() && this.Operator == NEGATIVE)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandBddEncoding = this.Argument1.TranslateIntExpToBDD(model);
for (int i = 0; i < operandBddEncoding.Count(); i++)
{
result.GuardDDs.Add(operandBddEncoding.GuardDDs[i]);
result.ExpressionDDs.Add(CUDD.Function.Minus(CUDD.Constant(0), operandBddEncoding.ExpressionDDs[i]));
}
return result;
}
else
{
ExpressionBDDEncoding operandBddEncoding = this.Argument1.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
for (int i = 0; i < operandBddEncoding.Count(); i++)
{
result.ExpressionDDs.Add(operandBddEncoding.GuardDDs[i]);
result.GuardDDs.Add(CUDD.Constant(1));
}
return result;
}
}
/// <summary>
/// For Update, If While, Sequence. Based on the current variable values in resultBefore, return the variable values after the statement is executed
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public virtual ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
return(new ExpressionBDDEncoding());
}
/// <summary>
/// Can support array of array
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private ExpressionBDDEncoding TranslateArrayExpression(Model model)
{
if (this.Argument2 is IntConstant)
{
int indexValue = ((IntConstant)this.Argument2).Value;
if(Operator == ARRAY)
{
return new Variable(this.Argument1 + Model.NAME_SEPERATOR + indexValue).TranslateIntExpToBDD(model);
}
else
{
return new VariablePrime(this.Argument1 + Model.NAME_SEPERATOR + indexValue).TranslateIntExpToBDD(model);
}
}
ExpressionBDDEncoding indexBddEncoding = this.Argument2.TranslateIntExpToBDD(model);
//Get the array range
int min = model.GetArrayRange(this.Argument1.ExpressionID)[0];
int max = model.GetArrayRange(this.Argument1.ExpressionID)[1];
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
//a[i]
for (int i = min; i <= max; i++)
{
for(int j = 0; j < indexBddEncoding.Count(); j++)
{
//index = i & guard of index
CUDD.Ref(indexBddEncoding.ExpressionDDs[j], indexBddEncoding.GuardDDs[j]);
CUDDNode guard = CUDD.Function.And(CUDD.Function.Equal(indexBddEncoding.ExpressionDDs[j], CUDD.Constant(i)),
indexBddEncoding.GuardDDs[j]);
if(guard != CUDD.ZERO)
{
//a[i]
result.GuardDDs.Add(guard);
Expression arrayExpression;
if(Operator == ARRAY)
{
arrayExpression = new Variable(this.Argument1.ExpressionID + Model.NAME_SEPERATOR + i);
}
else
{
arrayExpression = new VariablePrime(this.Argument1.ExpressionID + Model.NAME_SEPERATOR + i);
}
result.ExpressionDDs.Add(arrayExpression.TranslateIntExpToBDD(model).ExpressionDDs[0]);
}
else
{
CUDD.Deref(guard);
}
}
}
//dereference later because 2 loops above
indexBddEncoding.DeRef();
return result;
}
private ExpressionBDDEncoding TranslateLogicalBinaryExpression(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandTranslation1 = this.Argument1.TranslateBoolExpToBDD(model);
ExpressionBDDEncoding operandTranslation2 = this.Argument2.TranslateBoolExpToBDD(model);
List<CUDDNode> operand1 = (operandTranslation1.Count() > 0)? operandTranslation1.GuardDDs: new List<CUDDNode>();
List<CUDDNode> operand2 = (operandTranslation2.Count() > 0) ? operandTranslation2.GuardDDs : new List<CUDDNode>();
switch (this.Operator)
{
case AND:
result.GuardDDs = CUDD.Function.And(operand1, operand2);
break;
case OR:
result.GuardDDs.AddRange(operand1);
result.GuardDDs.AddRange(operand2);
break;
default:
throw new Exception("Unknown operator");
}
return result;
}
private ExpressionBDDEncoding TranslateNumericalBinaryExpression(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandTranslation1 = this.Argument1.TranslateIntExpToBDD(model);
ExpressionBDDEncoding operandTranslation2 = this.Argument2.TranslateIntExpToBDD(model);
for (int i = 0; i < operandTranslation1.Count(); i++)
{
for (int j = 0; j < operandTranslation2.Count(); j++)
{
CUDD.Ref(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
CUDDNode guard = CUDD.Function.And(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
if (guard.Equals(CUDD.ZERO))
{
CUDD.Deref(guard);
continue;
}
CUDDNode ex;
CUDD.Ref(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
switch (this.Operator)
{
case PLUS:
ex = CUDD.Function.Plus(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MINUS:
ex = CUDD.Function.Minus(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case TIMES:
ex = CUDD.Function.Times(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case DIVIDE:
ex = CUDD.Function.Divide(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MOD:
ex = CUDD.Function.Modulo(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MIN:
ex = CUDD.Function.Minimum(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MAX:
ex = CUDD.Function.Maximum(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
default:
throw new Exception("Unknown operator");
}
result.GuardDDs.Add(guard);
result.ExpressionDDs.Add(ex);
}
}
//Remove all old guard, expression
operandTranslation1.DeRef();
operandTranslation2.DeRef();
return result;
}
private ExpressionBDDEncoding TranslateRelationalBinaryExpression(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandTranslation1 = this.Argument1.TranslateIntExpToBDD(model);
ExpressionBDDEncoding operandTranslation2 = this.Argument2.TranslateIntExpToBDD(model);
CUDDNode guardOfResult = CUDD.Constant(0);
for (int i = 0; i < operandTranslation1.Count(); i++)
{
for (int j = 0; j < operandTranslation2.Count(); j++)
{
CUDD.Ref(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
CUDDNode guardDD = CUDD.Function.And(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
if (guardDD.Equals(CUDD.ZERO))
{
CUDD.Deref(guardDD);
continue;
}
CUDDNode expressionDD;
CUDD.Ref(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
switch (this.Operator)
{
case EQUAL:
expressionDD = CUDD.Function.Equal(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case NOT_EQUAL:
expressionDD = CUDD.Function.NotEqual(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case GREATER:
expressionDD = CUDD.Function.Greater(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case GREATER_EQUAL:
expressionDD = CUDD.Function.GreaterEqual(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case LESS:
expressionDD = CUDD.Function.Less(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case LESS_EQUAL:
expressionDD = CUDD.Function.LessEqual(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
default:
throw new Exception("Unknown operator");
}
guardDD = CUDD.Function.And(guardDD, expressionDD);
if (guardDD.Equals(CUDD.ZERO))
{
CUDD.Deref(guardDD);
continue;
}
guardOfResult = CUDD.Function.Or(guardOfResult, guardDD);
}
}
result.AddNodeToGuard(guardOfResult);
//Remove all old guard, expression
operandTranslation1.DeRef();
operandTranslation2.DeRef();
return result;
}
/// <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.TEMPORARY_VARIABLE));
tempResult2.GuardDDs[i] = CUDD.Abstract.ThereExists(tempResult2.GuardDDs[i], model.GetColVars(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>
/// Used as a special statement which does nothing
/// </summary>
public override ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
if (Value)
{
return resultBefore;
}
else
{
return new ExpressionBDDEncoding();
}
}
/// <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;
}
}
/// <summary>
/// For Update, If While, Sequence. Based on the current variable values in resultBefore, return the variable values after the statement is executed
/// [ REFS: 'result', DEREFS: 'resultBefore' ]
/// </summary>
public virtual ExpressionBDDEncoding TranslateStatementToBDD(ExpressionBDDEncoding resultBefore, Model model)
{
return new ExpressionBDDEncoding();
}
private ExpressionBDDEncoding TranslateNumericalBinaryExpression(Model model)
{
ExpressionBDDEncoding result = new ExpressionBDDEncoding();
ExpressionBDDEncoding operandTranslation1 = this.Argument1.TranslateIntExpToBDD(model);
ExpressionBDDEncoding operandTranslation2 = this.Argument2.TranslateIntExpToBDD(model);
for (int i = 0; i < operandTranslation1.Count(); i++)
{
for (int j = 0; j < operandTranslation2.Count(); j++)
{
CUDD.Ref(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
CUDDNode guard = CUDD.Function.And(operandTranslation1.GuardDDs[i], operandTranslation2.GuardDDs[j]);
if (guard.Equals(CUDD.ZERO))
{
CUDD.Deref(guard);
continue;
}
CUDDNode ex;
CUDD.Ref(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
switch (this.Operator)
{
case PLUS:
ex = CUDD.Function.Plus(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MINUS:
ex = CUDD.Function.Minus(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case TIMES:
ex = CUDD.Function.Times(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case DIVIDE:
ex = CUDD.Function.Divide(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MOD:
ex = CUDD.Function.ModuloNonNegative(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case NON_NEGATIVE_MOD:
ex = CUDD.Function.ModuloNonNegative(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MIN:
ex = CUDD.Function.Minimum(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
case MAX:
ex = CUDD.Function.Maximum(operandTranslation1.ExpressionDDs[i], operandTranslation2.ExpressionDDs[j]);
break;
default:
throw new Exception("Unknown operator");
}
result.GuardDDs.Add(guard);
result.ExpressionDDs.Add(ex);
}
}
//Remove all old guard, expression
operandTranslation1.DeRef();
operandTranslation2.DeRef();
return(result);
}
