/// <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); }