public Constraint AddAutomaton(IEnumerable <IntVar> vars, long starting_state,
IEnumerable <Tuple <long, long, long> > transitions, IEnumerable <long> final_states)
{
Constraint ct = new Constraint(model_);
AutomatonConstraintProto aut = new AutomatonConstraintProto();
foreach (IntVar var in vars)
{
aut.Vars.Add(var.Index);
}
aut.StartingState = starting_state;
foreach (long f in final_states)
{
aut.FinalStates.Add(f);
}
foreach (Tuple <long, long, long> transition in transitions)
{
aut.TransitionHead.Add(transition.Item1);
aut.TransitionLabel.Add(transition.Item2);
aut.TransitionTail.Add(transition.Item3);
}
ct.Proto.Automaton = aut;
return(ct);
}
public Constraint AddAutomaton(IEnumerable <IntVar> vars, long starting_state, long[,] transitions,
IEnumerable <long> final_states)
{
Constraint ct = new Constraint(model_);
AutomatonConstraintProto aut = new AutomatonConstraintProto();
foreach (IntVar var in vars)
{
aut.Vars.Add(var.Index);
}
aut.StartingState = starting_state;
foreach (long f in final_states)
{
aut.FinalStates.Add(f);
}
for (int i = 0; i < transitions.GetLength(0); ++i)
{
aut.TransitionTail.Add(transitions[i, 0]);
aut.TransitionLabel.Add(transitions[i, 1]);
aut.TransitionHead.Add(transitions[i, 2]);
}
ct.Proto.Automaton = aut;
return(ct);
}
/*
* <summary>
* Adds a transitions to the automaton.
* </summary>
*/
public AutomatonConstraint AddTransition(int tail, int head, long label)
{
AutomatonConstraintProto aut = Proto.Automaton;
aut.TransitionTail.Add(tail);
aut.TransitionLabel.Add(label);
aut.TransitionHead.Add(head);
return(this);
}
/**
* <summary>
* Adds an automaton constraint.
* </summary>
*
* <remarks>
* <para>An automaton constraint takes a list of variables (of size n), an initial state, a set of
* final states, and a set of transitions that will be added incrementally directly on the
* returned AutomatonConstraint instance. A transition is a triplet (<c>tail</c>, <c>transition</c>,
* <c>head</c>), where <c>tail</c> and <c>head</c> are states, and <c>transition</c> is the label of an arc from
* <c>head</c> to <c>tail</c>, corresponding to the value of one variable in the list of variables. </para>
*
* <para>This automaton will be unrolled into a flow with n + 1 phases. Each phase contains the
* possible states of the automaton. The first state contains the initial state. The last phase
* contains the final states. </para>
*
* <para>Between two consecutive phases i and i + 1, the automaton creates a set of arcs. For each
* transition (<c>tail</c>, <c>label</c>, <c>head</c>), it will add an arc from the state <c>tail</c> of phase i and
* the state <c>head</c> of phase i + 1. This arc labeled by the value <c>label</c> of the variables
* <c>variables[i]</c>. That is, this arc can only be selected <c>variables[i]</c>a is assigned the value
* <c>label</c>. </para>
*
* <para>A feasible solution of this constraint is an assignment of variables such that, starting
* from the initial state in phase 0, there is a path labeled by the values of the variables that
* ends in one of the final states in the final phase. </para>
* </remarks>
*
* <param name="vars"> a non empty list of variables whose values correspond to the labels
* of the arcs traversed by the automaton</param>
* <param name="starting_state"> the initial state of the automaton</param>
* <param name="final_states"> a non empty list of admissible final states </param>
* <returns> an instance of the AutomatonConstraint class </returns>
*/
public AutomatonConstraint AddAutomaton(IEnumerable <IntVar> vars, long starting_state,
IEnumerable <long> final_states)
{
AutomatonConstraintProto aut = new AutomatonConstraintProto();
aut.Vars.TrySetCapacity(vars);
foreach (IntVar var in vars)
{
aut.Vars.Add(var.Index);
}
aut.StartingState = starting_state;
aut.FinalStates.AddRange(final_states);
AutomatonConstraint ct = new AutomatonConstraint(model_);
ct.Proto.Automaton = aut;
return(ct);
}
