public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
return(AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD processAutomataBDD = this.Process.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(this.Event);
//
return(AutomataBDD.EventPrefix(new BoolConstant(true), eventUpdateExpression, processAutomataBDD, encoder.model));
}
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
AutomataBDD process1BDD = this.FirstProcess.Encode(encoder);
AutomataBDD process2BDD = this.SecondProcess.Encode(encoder);
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
//
AutomataBDD ifBDD = AutomataBDD.EventPrefix(this.ConditionalExpression, eventUpdateExpression, process1BDD, encoder.model);
AutomataBDD elseBDD = AutomataBDD.EventPrefix(Expression.NOT(this.ConditionalExpression), eventUpdateExpression, process2BDD, encoder.model);
//
return(AutomataBDD.Choice(new List <AutomataBDD> {
ifBDD, elseBDD
}, encoder.model));
}
/// <summary>
/// P = [] {[guardi] tau -> Pi}
/// </summary>
/// <param name="encoder"></param>
/// <returns></returns>
public override AutomataBDD EncodeComposition(BDDEncoder encoder)
{
List <AutomataBDD> processAutomataBDDs = new List <AutomataBDD>();
Expression previousguardsOR = null;
Expression eventUpdateExpression = encoder.GetEventExpression(new Event(Constants.TAU));
for (int i = 0; i < Processes.Length; i++)
{
Expression guard = null;
if (i == 0)
{
guard = Conditions[i];
}
else //if (previousguardsOR != null)
{
guard = Expression.AND(guard, Expression.NOT(previousguardsOR));
}
AutomataBDD processAutomataBDd = Processes[i].Encode(encoder);
AutomataBDD guardProcessAutomataBDD = AutomataBDD.EventPrefix(guard, eventUpdateExpression, processAutomataBDd, encoder.model);
processAutomataBDDs.Add(guardProcessAutomataBDD);
previousguardsOR = Expression.OR(previousguardsOR, guard);
}
//if all conditions are not satisfied, it becomes Skip
Expression allConditions = new BoolConstant(true);
foreach (var condition in Conditions)
{
allConditions = Expression.OR(allConditions, condition);
}
processAutomataBDDs.Add(AutomataBDD.EventPrefix(Expression.NOT(allConditions), eventUpdateExpression, new Skip().Encode(encoder), encoder.model));
return(AutomataBDD.Choice(processAutomataBDDs, encoder.model));
}
/// <summary>
/// Encode transition, if it is synchronized, then we don't add constraint of unchanged global variables
/// Parallel process only synchorinize event which does not change global variable or each transition changes same to global variables
/// 3 kinds of transition: normal event, async channel input and async channel output
/// </summary>
/// <param name="encoder"></param>
/// <param name="processVariableName"></param>
/// <param name="localVars">Local of the current SymbolicLTS is unchanged</param>
/// <param name="isSynchronized"></param>
/// <returns></returns>
public List <CUDDNode> Encode(BDDEncoder encoder, string processVariableName, List <int> localVars, bool isSynchronized)
{
Expression guardExpressions = Expression.EQ(new Variable(processVariableName),
new IntConstant(encoder.stateIndexOfCurrentProcess[this.FromPNPlace.ID]));
guardExpressions = Expression.CombineGuard(guardExpressions, GuardCondition);
Expression eventUpdateExpression;
if (this.Event is BDDEncoder.EventChannelInfo)
{
int channelIndex = encoder.GetChannelIndex(this.Event.BaseName, (this.Event as BDDEncoder.EventChannelInfo).type);
eventUpdateExpression = new Assignment(Model.EVENT_NAME, new IntConstant(channelIndex));
}
else
{
eventUpdateExpression = encoder.GetEventExpression(this.Event);
}
Assignment PNPlaceUpdateExpression = new Assignment(processVariableName,
new IntConstant(encoder.stateIndexOfCurrentProcess[this.ToPNPlace.ID]));
Sequence updateExpressions = new Sequence(eventUpdateExpression, PNPlaceUpdateExpression);
if (this.ProgramBlock != null)
{
updateExpressions = new Sequence(updateExpressions, this.ProgramBlock);
}
List <int> unchangedVars = new List <int>(localVars);
if (!isSynchronized)
{
unchangedVars.AddRange(encoder.model.GlobalVarIndex);
}
return(encoder.model.EncodeTransition(guardExpressions, updateExpressions, unchangedVars));
}
