/// <summary>
/// Returns a strategy to reach targets from a vertex.
/// </summary>
/// <param name="vertex"></param>
/// <returns></returns>
internal Strategy[] GetStrategyReachableFromVertex(int vertex)
{
Strategy [] strategies = this.GetStrategies();
if (VertIsNondet(vertex))
{
throw new ArgumentException("vertex is a choice point");
}
//ArrayList links=new ArrayList();
HSet linkSet = new HSet();
foreach (Strategy s in strategies)
{
if (s.edge != null)
{
linkSet.Insert(s.edge);
if (VertIsNondet(s.edge.target))
{
foreach (Edge l in graph.EdgesAtVertex(s.edge.target))
{
linkSet.Insert(l);
}
}
}
}
BasicGraph bg = new BasicGraph(0, linkSet.ToArray(typeof(Edge)));
bool [] reachables = bg.GetReachableArray(vertex);
for (int i = 0; i < reachables.Length; i++)
{
if (reachables[i] == false)
{
strategies[i].edge = null;
}
}
return(strategies);
}
void GetReachableFromVertex(int i, HSet covered, int stepsLeft, HSet result, bool skipChoicePoints, int totalSteps)
{
if (stepsLeft == 0 || covered.Contains(i))
{
return;
}
covered.Insert(i);
foreach (Edge l in this.EdgesAtVertex(i))
{
result.Insert(l);
if (skipChoicePoints == false)
{
GetReachableFromVertex(l.target, covered,
stepsLeft - 1, result, skipChoicePoints, totalSteps);
}
else if (this.IsChoicePoint(l.target) == false)
{
GetReachableFromVertex(l.target,
covered, stepsLeft - 1, result, skipChoicePoints, totalSteps);
}
else //choice point
{
GetReachableFromVertex(l.target, covered,
totalSteps, result, skipChoicePoints, totalSteps);
}
}
}
/// <summary>
/// edge[u,v] where v is in the front
/// take values from S and updates Sn
/// </summary>
/// <param name="edge"></param>
void Process(Edge edge)
{
int u = edge.source;
int v = edge.target;
if (P.Contains(u))
{
return;
}
if (VertIsNondet(u))
{
if (this.newfront.Contains(u))
{
return;
}
double p = 0.0;
int w = 0;
foreach (Edge ulink in this.graph.EdgesAtVertex(u))
{
p += graph.EdgeProbability(ulink) * S[ulink.target].prob;
int wn = ulink.weight + S[ulink.target].weight;
if (wn > w)
{
w = wn;
}
}
S[u].newProb = (float)p;
S[u].newWeight = w;
newfront.Insert(u);
}
else if (Improving(edge))
{
S[u].newEdge = edge;
S[u].newProb = S[v].prob;
S[u].newWeight = edge.weight + S[v].weight;
newfront.Insert(u);
}
}
/// <summary>
/// Set union.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static HSet operator +(HSet a, HSet b)
{
HSet ret=new HSet(a);
foreach( object o in b)
ret.Insert(o);
return ret;
}
/// <summary>
/// Clones the set.
/// </summary>
/// <returns></returns>
public HSet Clone()
{
HSet ret = new HSet();
foreach (object i in this)
{
ret.Insert(i);
}
return(ret);
}
/// <summary>
/// Set union.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static HSet operator+(HSet a, HSet b)
{
HSet ret = new HSet(a);
foreach (object o in b)
{
ret.Insert(o);
}
return(ret);
}
/// <summary>
/// Set difference.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static HSet operator-(HSet a, HSet b)
{
HSet ret = new HSet();
foreach (object o in a)
{
if (!b.Contains(o))
{
ret.Insert(o);
}
}
return(ret);
}
internal HSet DeadStates(int[] acceptingStates)
{
try {
InitBackwardEdges();
Queue q = new Queue();
HSet aliveSet = new HSet(acceptingStates);
foreach (int i in acceptingStates)
{
if (i < NumberOfVertices)
{
q.Enqueue(i);
}
}
while (q.Count > 0)
{
int u = (int)q.Dequeue();
foreach (int v in Pred(u))
{
if (!aliveSet.Contains(v))
{
aliveSet.Insert(v);
q.Enqueue(v);
}
}
}
HSet deadSet = new HSet();
//adding the deads
int n = NumberOfVertices;
for (int i = 0; i < n; i++)
{
if (!aliveSet.Contains(i))
{
deadSet.Insert(i);
}
}
return(deadSet);
}
catch {
return(new HSet());
}
}
/// <summary>
/// </summary>
/// <param name="initialVertex">the initial vertex - usually 0</param>
/// <param name="mustEdges">the edge considered as must in Chinese Postman route</param>
/// <param name="optionalEdges">the edges considered as optional in Chinese Postman route</param>
/// <param name="nondetVertices">the vertices where the system behaves non-deterministically</param>
/// <param name="closureInstr">this instruction will shuffle some optional edges to must ones. Chinese Rural Postman works only when the set of must links is weakly closed</param>
internal Graph(int initialVertex, Edge[] mustEdges, Edge[] optionalEdges, int [] nondetVertices, WeakClosureEnum closureInstr)
: this(initialVertex, mustEdges, optionalEdges, closureInstr)
{
this.nondNeighbours = new RBMap();
foreach (int p in nondetVertices)
{
if (p < this.NumberOfVertices)
{
HSet s = (this.nondNeighbours[p] = new HSet()) as HSet;
foreach (Edge l in this.graph.EdgesAtVertex(p))
{
s.Insert(l.target);
}
}
}
}
internal HSet DeadStatesWithoutChangingChoicePoints(int[] acceptingStates)
{
try {
InitBackwardEdges();
Queue q=new Queue();
HSet deadSet=new HSet();
bool done=false;
HSet targetSet=new HSet();
foreach(int i in acceptingStates)
if(i<NumberOfVertices)
targetSet.Insert(i);
while(!done){
done=true;
//alives can reach acceptingStates by not passing through deads
HSet aliveSet=new HSet(targetSet);
foreach(int i in targetSet)
q.Enqueue(i);
while(q.Count>0)
{
int u=(int)q.Dequeue();
foreach( int v in Pred(u))
{
if(!aliveSet.Contains(v)&&!deadSet.Contains(v))
{
aliveSet.Insert(v);
q.Enqueue(v);
}
}
}
//adding new deads
int n=NumberOfVertices;
for(int i=0;i<n;i++)
if(! aliveSet.Contains(i) && !deadSet.Contains(i))
{
done=false; //we are not done since we've found a new dead
q.Enqueue(i);
deadSet.Insert(i);
}
while(q.Count>0)
{
int u=(int)q.Dequeue();
foreach(int v in Pred(u))
{
if(deadSet.Contains(v)==false&& targetSet.Contains(v)==false)
{
if(this.IsChoicePoint(v))
{
deadSet.Insert(v);
q.Enqueue(v);
}
else {
bool isDead=true;
foreach(int w in Succ(v))
{
if(deadSet.Contains(w)==false)
{
isDead=false;
break;
}
}
if(isDead)
{
deadSet.Insert(v);
q.Enqueue(v);
}
}
}
}
}
}
//add to deadSet everything that cannot be reached from the initial vertex
HSet alSet=new HSet();
if(NumberOfVertices>0)
if(!deadSet.Contains(initVertex))
{
q.Enqueue(initVertex);
alSet.Insert(initVertex);
while(q.Count>0)
{
int u=(int)q.Dequeue();
foreach(int v in Succ(u))
if(!deadSet.Contains(v))
if(!alSet.Contains(v))
{
alSet.Insert(v);
q.Enqueue(v);
}
}
}
for(int i=0;i<NumberOfVertices;i++){
if(!alSet.Contains(i))
deadSet.Insert(i);
}
return deadSet;
}
catch{
return new HSet();
}
}
/// <summary>
/// Clones the set.
/// </summary>
/// <returns></returns>
public HSet Clone()
{
HSet ret=new HSet();
foreach(object i in this)
{
ret.Insert(i);
}
return ret;
}
void GetReachableFromVertex(int i,HSet covered, int stepsLeft,HSet result,bool skipChoicePoints,int totalSteps)
{
if(stepsLeft==0 || covered.Contains(i))
return;
covered.Insert(i);
foreach(Edge l in this.EdgesAtVertex(i)){
result.Insert(l);
if(skipChoicePoints==false)
GetReachableFromVertex(l.target,covered,
stepsLeft-1,result,skipChoicePoints,totalSteps);
else if (this.IsChoicePoint(l.target)==false)
GetReachableFromVertex(l.target,
covered,stepsLeft-1,result,skipChoicePoints,totalSteps);
else //choice point
GetReachableFromVertex(l.target,covered,
totalSteps,result,skipChoicePoints,totalSteps);
}
}
internal HSet DeadStatesWithoutChangingChoicePoints(int[] acceptingStates)
{
try {
InitBackwardEdges();
Queue q = new Queue();
HSet deadSet = new HSet();
bool done = false;
HSet targetSet = new HSet();
foreach (int i in acceptingStates)
{
if (i < NumberOfVertices)
{
targetSet.Insert(i);
}
}
while (!done)
{
done = true;
//alives can reach acceptingStates by not passing through deads
HSet aliveSet = new HSet(targetSet);
foreach (int i in targetSet)
{
q.Enqueue(i);
}
while (q.Count > 0)
{
int u = (int)q.Dequeue();
foreach (int v in Pred(u))
{
if (!aliveSet.Contains(v) && !deadSet.Contains(v))
{
aliveSet.Insert(v);
q.Enqueue(v);
}
}
}
//adding new deads
int n = NumberOfVertices;
for (int i = 0; i < n; i++)
{
if (!aliveSet.Contains(i) && !deadSet.Contains(i))
{
done = false; //we are not done since we've found a new dead
q.Enqueue(i);
deadSet.Insert(i);
}
}
while (q.Count > 0)
{
int u = (int)q.Dequeue();
foreach (int v in Pred(u))
{
if (deadSet.Contains(v) == false && targetSet.Contains(v) == false)
{
if (this.IsChoicePoint(v))
{
deadSet.Insert(v);
q.Enqueue(v);
}
else
{
bool isDead = true;
foreach (int w in Succ(v))
{
if (deadSet.Contains(w) == false)
{
isDead = false;
break;
}
}
if (isDead)
{
deadSet.Insert(v);
q.Enqueue(v);
}
}
}
}
}
}
//add to deadSet everything that cannot be reached from the initial vertex
HSet alSet = new HSet();
if (NumberOfVertices > 0)
{
if (!deadSet.Contains(initVertex))
{
q.Enqueue(initVertex);
alSet.Insert(initVertex);
while (q.Count > 0)
{
int u = (int)q.Dequeue();
foreach (int v in Succ(u))
{
if (!deadSet.Contains(v))
{
if (!alSet.Contains(v))
{
alSet.Insert(v);
q.Enqueue(v);
}
}
}
}
}
}
for (int i = 0; i < NumberOfVertices; i++)
{
if (!alSet.Contains(i))
{
deadSet.Insert(i);
}
}
return(deadSet);
}
catch {
return(new HSet());
}
}
/// <summary>
/// Set difference.
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public static HSet operator -(HSet a, HSet b)
{
HSet ret=new HSet();
foreach( object o in a)
if(!b.Contains(o))
ret.Insert(o);
return ret;
}
static internal EdgesAndExpectations GetStaticStrategy(Graph graph,
int[] sources,
HSet targets,
int nStates,
int resetCost,
int [] deadStates)
{
foreach (int t in targets)
{
foreach (Edge l in graph.EdgesAtVertex(t))
{
l.weight = 0;
}
}
//fix the edges weights
foreach (Edge l in graph.MustEdges)
{
if (l.target >= nStates)
{
l.weight = 0;
}
}
foreach (Edge l in graph.OptionalEdges)
{
l.weight = resetCost;
}
if (graph.NumberOfVertices > 1000)//Value iteration becomes too slow
{
return(graph.GetStaticStrategyWithDistancesToAcceptingStates(sources, targets.ToArray(typeof(int)) as int[]));
}
HSet deadStatesSet = new HSet(deadStates);
//create reachableGraph
bool [] reachableVerts = new bool[graph.NumberOfVertices];
//we have to walk backwards from the targets avoiding dead states
graph.InitBackwardEdges();
foreach (int i in targets)
{
reachableVerts[i] = true;
}
System.Collections.Queue queue = new System.Collections.Queue(targets);
while (queue.Count > 0)
{
int i = (int)queue.Dequeue();
foreach (int v in graph.Pred(i))
{
if (!reachableVerts[v] && !deadStatesSet.Contains(v))
{
queue.Enqueue(v);
reachableVerts[v] = true;
}
}
}
int numberOfReachableVerts = 0;
foreach (bool b in reachableVerts)
{
if (b)
{
numberOfReachableVerts++;
}
}
Edge[] strategyEdges;
double [] expectations;
if (numberOfReachableVerts == graph.NumberOfVertices)
{
expectations = GetExpectations(graph, /* sources,*/ targets, nStates);
if (expectations == null)
{
return(new EdgesAndExpectations());
}
strategyEdges = new Edge[nStates];
for (int i = 0; i < nStates && i < graph.NumberOfVertices; i++)
{
if (targets.Contains(i) || deadStatesSet.Contains(i))
{
continue;
}
double min = Single.MaxValue;
Edge stEdge = null;
foreach (Edge l in graph.EdgesAtVertex(i))
{
int j = l.target;
if (expectations[j] < min)
{
min = expectations[j];
stEdge = l;
}
}
strategyEdges[i] = stEdge;
}
}
else
{ //numberOfReachableVerts<graph.NumberOfVertices)
int [] graphToRG = new int[graph.NumberOfVertices];
//reachable graph to graph
int [] rGToGraph = new int[numberOfReachableVerts];
int count = 0;
int rNStates = 0;
for (int i = 0; i < reachableVerts.Length; i++)
{
if (reachableVerts[i])
{
graphToRG[i] = count;
rGToGraph[count] = i;
count++;
if (i < nStates)
{
rNStates++;
}
}
}
System.Collections.ArrayList mustEdges = new System.Collections.ArrayList();
foreach (Edge l in graph.MustEdges)
{
if (reachableVerts[l.source] && reachableVerts[l.target])
{
Edge ml = new Edge(graphToRG[l.source], graphToRG[l.target], l.label, l.weight);
mustEdges.Add(ml);
}
}
System.Collections.ArrayList nondVerts = new System.Collections.ArrayList();
for (int i = nStates; i < graph.NumberOfVertices; i++)
{
if (reachableVerts[i])
{
nondVerts.Add(graphToRG[i]);
}
}
Graph rGraph = new Graph(0, mustEdges.ToArray(typeof(Edge)) as Edge[], new Edge[0],
nondVerts.ToArray(typeof(int)) as int[], true, WeakClosureEnum.DoNotClose);
int [] rSources = new int[sources.Length];
int c = 0;
foreach (int s in sources)
{
rSources[c++] = graphToRG[s];
}
HSet rTargets = new HSet();
foreach (int s in targets)
{
if (reachableVerts[s])
{
rTargets.Insert(graphToRG[s]);
}
}
double [] rExpectations = GetExpectations(rGraph, /*rSources,*/ rTargets, rNStates);
if (rExpectations == null)
{
return(new EdgesAndExpectations());
}
strategyEdges = new Edge[nStates];
for (int i = 0; i < nStates; i++)
{
if (!reachableVerts[i])
{
continue;
}
if (targets.Contains(i) || deadStatesSet.Contains(i))
{
continue;
}
double min = Single.MaxValue;
Edge stEdge = null;
foreach (Edge l in graph.EdgesAtVertex(i))
{
int j = l.target;
if (reachableVerts[j])
{
if (rExpectations[graphToRG[j]] < min)
{
min = rExpectations[graphToRG[j]];
stEdge = l;
}
}
}
strategyEdges[i] = stEdge;
}
expectations = new double[graph.NumberOfVertices];
if (expectations == null)
{
return(new EdgesAndExpectations());
}
for (int i = 0; i < expectations.Length; i++)
{
expectations[i] = Int32.MaxValue;
}
for (int i = 0; i < rExpectations.Length; i++)
{
expectations[rGToGraph[i]] = rExpectations[i];
}
}
graph.CleanTheStrategy(strategyEdges, sources);
return(new EdgesAndExpectations(strategyEdges, expectations));
}
internal HSet DeadStates(int[] acceptingStates)
{
try {
InitBackwardEdges();
Queue q=new Queue();
HSet aliveSet=new HSet(acceptingStates);
foreach(int i in acceptingStates)
if(i<NumberOfVertices)
q.Enqueue(i);
while(q.Count>0){
int u=(int)q.Dequeue();
foreach( int v in Pred(u))
{
if(!aliveSet.Contains(v))
{
aliveSet.Insert(v);
q.Enqueue(v);
}
}
}
HSet deadSet=new HSet();
//adding the deads
int n=NumberOfVertices;
for(int i=0;i<n;i++)
if(! aliveSet.Contains(i))
{
deadSet.Insert(i);
}
return deadSet;
}
catch{
return new HSet();
}
}
/// <summary>
/// Returns a strategy to reach targets from a vertex.
/// </summary>
/// <param name="vertex"></param>
/// <returns></returns>
internal Strategy[] GetStrategyReachableFromVertex(int vertex)
{
Strategy [] strategies=this.GetStrategies();
if(VertIsNondet(vertex))
throw new ArgumentException("vertex is a choice point");
//ArrayList links=new ArrayList();
HSet linkSet=new HSet();
foreach(Strategy s in strategies)
if(s.edge!=null){
linkSet.Insert(s.edge);
if(VertIsNondet( s.edge.target))
foreach(Edge l in graph.EdgesAtVertex(s.edge.target))
linkSet.Insert(l);
}
BasicGraph bg=new BasicGraph(0, linkSet.ToArray(typeof(Edge)) );
bool []reachables=bg.GetReachableArray(vertex);
for(int i=0;i<reachables.Length;i++){
if(reachables[i]==false)
strategies[i].edge=null;
}
return strategies;
}
internal static EdgesAndExpectations GetStaticStrategy(Graph graph,
int[] sources,
HSet targets,
int nStates,
int resetCost,
int []deadStates)
{
foreach(int t in targets){
foreach(Edge l in graph.EdgesAtVertex(t))
l.weight=0;
}
//fix the edges weights
foreach(Edge l in graph.MustEdges){
if(l.target>=nStates)
l.weight=0;
}
foreach(Edge l in graph.OptionalEdges)
l.weight=resetCost;
if(graph.NumberOfVertices>1000){//Value iteration becomes too slow
return graph.GetStaticStrategyWithDistancesToAcceptingStates(sources, targets.ToArray(typeof(int)) as int[]);
}
HSet deadStatesSet=new HSet(deadStates);
//create reachableGraph
bool []reachableVerts=new bool[graph.NumberOfVertices];
//we have to walk backwards from the targets avoiding dead states
graph.InitBackwardEdges();
foreach(int i in targets)
reachableVerts[i]=true;
System.Collections.Queue queue=new System.Collections.Queue(targets);
while(queue.Count>0)
{
int i=(int)queue.Dequeue();
foreach(int v in graph.Pred(i))
{
if(!reachableVerts[v] && !deadStatesSet.Contains(v))
{
queue.Enqueue(v);
reachableVerts[v]=true;
}
}
}
int numberOfReachableVerts=0;
foreach(bool b in reachableVerts)
if(b)
numberOfReachableVerts++;
Edge[] strategyEdges;
double [] expectations;
if(numberOfReachableVerts==graph.NumberOfVertices)
{
expectations=GetExpectations(graph,/* sources,*/targets,nStates);
if(expectations==null)
return new EdgesAndExpectations();
strategyEdges=new Edge[nStates];
for(int i=0;i<nStates&&i<graph.NumberOfVertices;i++){
if(targets.Contains(i)||deadStatesSet.Contains(i))
continue;
double min=Single.MaxValue;
Edge stEdge=null;
foreach(Edge l in graph.EdgesAtVertex(i)){
int j=l.target;
if(expectations[j]<min){
min=expectations[j];
stEdge=l;
}
}
strategyEdges[i]=stEdge;
}
}
else
{ //numberOfReachableVerts<graph.NumberOfVertices)
int [] graphToRG=new int[graph.NumberOfVertices];
//reachable graph to graph
int [] rGToGraph=new int[numberOfReachableVerts];
int count=0;
int rNStates=0;
for(int i=0;i<reachableVerts.Length;i++)
if(reachableVerts[i])
{
graphToRG[i]=count;
rGToGraph[count]=i;
count++;
if(i<nStates)
rNStates++;
}
System.Collections.ArrayList mustEdges=new System.Collections.ArrayList();
foreach(Edge l in graph.MustEdges)
{
if( reachableVerts[l.source]&& reachableVerts[l.target])
{
Edge ml=new Edge(graphToRG[l.source],graphToRG[l.target], l.label,l.weight);
mustEdges.Add(ml);
}
}
System.Collections.ArrayList nondVerts=new System.Collections.ArrayList();
for(int i=nStates;i<graph.NumberOfVertices;i++)
{
if(reachableVerts[i])
nondVerts.Add(graphToRG[i]);
}
Graph rGraph=new Graph(0,mustEdges.ToArray(typeof(Edge)) as Edge[],new Edge[0],
nondVerts.ToArray(typeof(int)) as int[],true,WeakClosureEnum.DoNotClose);
int []rSources=new int[sources.Length];
int c=0;
foreach(int s in sources)
{
rSources[c++]=graphToRG[s];
}
HSet rTargets=new HSet();
foreach(int s in targets)
{
if( reachableVerts[s])
{
rTargets.Insert(graphToRG[s]);
}
}
double []rExpectations=GetExpectations(rGraph,/*rSources,*/ rTargets,rNStates);
if(rExpectations==null)
return new EdgesAndExpectations();
strategyEdges=new Edge[nStates];
for(int i=0;i<nStates;i++){
if(!reachableVerts[i])
continue;
if(targets.Contains(i)||deadStatesSet.Contains(i))
continue;
double min=Single.MaxValue;
Edge stEdge=null;
foreach(Edge l in graph.EdgesAtVertex(i)){
int j=l.target;
if(reachableVerts[j])
if(rExpectations[graphToRG[j]]<min){
min=rExpectations[graphToRG[j]];
stEdge=l;
}
}
strategyEdges[i]=stEdge;
}
expectations=new double[graph.NumberOfVertices];
if(expectations==null)
return new EdgesAndExpectations();
for(int i=0;i<expectations.Length;i++)
expectations[i]=Int32.MaxValue;
for(int i=0;i<rExpectations.Length;i++)
expectations[rGToGraph[i]]=rExpectations[i];
}
graph.CleanTheStrategy(strategyEdges,sources);
return new EdgesAndExpectations(strategyEdges, expectations);
}