public override IEnumerable <Path <SS, DS> > Compute(SS ss, DS ds, Goal <SS, DS> Goal, Operator <SS, DS>[] Ops) { this.init(ss, ds, Ops, Goal); ExtendedDictionary <DS, Metric> H1 = new ExtendedDictionary <DS, Metric>(x => aS.h(x, aS.Sgoal)); ExtendedDictionary <DS, DS> tree = new ExtendedDictionary <DS, DS>(x => null); Path <SS, DS> Incumbant = null; int GlobalSearchLimit = GetGlobalSearchComputationLimit( ); this.aS.ComputationLimit = GlobalSearchLimit; int LocalSearchLimit = GetLocalSearchComputationLimit( ); foreach (Path <SS, DS> p in AnytimeDStarLiteLookahead(aS, GlobalSearchLimit)) { this.Expansions += aS.Expansions; this.Generations += aS.Generations; aS.Expansions = 0; aS.Generations = 0; if (p == null) { switch (sm) { /*case ChooseMethodStep.LRTAStar: * yield return LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss, * LocalSearchLimit, aS.sv, * ref this.Expansions, ref this.Generations, false, * Ops, H1, H, Goal, Metric.One, false ); * break; * case ChooseMethodStep.RTAStar: * yield return LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss, * LocalSearchLimit, aS.sv, * ref this.Expansions, ref this.Generations, false, * Ops, H1, H, Goal, Metric.One, true ); * break;*/ case ChooseMethodStep.LSSLRTAStar: yield return(LSSLRTAStar <SS, DS> .LSSLRTAStarLookahead(LocalSearchLimit, ss, aS.Sstart, aS.Sgoal, Ops, aS.h, ref Incumbant, ref this.Expansions, aS.sv, tree, H1)); break; } } else { yield return(p); } aS.Sstart = aS.ss.InitialDynamicState; } yield break; }
private Path <SS, DS> ChooseStep( ) { try { if (!ComputeShortestPathNormalTermination && !rhs(Sstart).Equals(Metric.PositiveInfinity)) { var ret = this.ExtractPath( ); (this.sv as OpenGLStateVisualizer).Global = true; return(ret); } else { (this.sv as OpenGLStateVisualizer).Global = false; if (sm.Equals(ChooseMethodStep.Null)) { return(null); } /// Choose a landmark goal state to step towards. DS LandmarkGoal = null; switch (lgm) { case ChooseMethodLandMarkGoal.UTop: LandmarkGoal = U.Top( ); break; case ChooseMethodLandMarkGoal.USample: LandmarkGoal = Nearest(Sstart, us); break; case ChooseMethodLandMarkGoal.Goal: LandmarkGoal = Sgoal; break; } if (LandmarkGoal == null) { return(null); } /// Choose the successor nodes we want to consider to move toward. IEnumerable <DS> succ = null; bool LLR = false; switch (fsm) { case ChooseMethodFilterSucc.All: succ = Succ(Sstart); break; case ChooseMethodFilterSucc.Lock: succ = Succ(Sstart); if (succ == null) { break; } succ = succ.Where(st => !this.LockedList.Contains(st)); if (succ.Count( ) == 0) { succ = Succ(Sstart); LLR = true; LockedList.Add(Sstart); } // Test if should add to dead end list. if (succ.Where(st => !this.LockedList.Contains(st)).All( ds => h(ds, LandmarkGoal) > h(Sstart, LandmarkGoal))) { LockedList.Add(Sstart); } break; } if (succ == null) { return(null); } /// Choose the state we want to step towards. DS next = null; switch (sm) { case ChooseMethodStep.MinHLandmarkGoal: this.Expansions++; this.Generations += (uint)succ.Count( ); next = succ.ArgMin(ds => h(ds, LandmarkGoal)); break; case ChooseMethodStep.MinHAdustedLandmarkGoal: this.Expansions++; this.Generations += (uint)succ.Count( ); Metric minV = null; foreach (var s in succ) { Metric h = hAdjusted(s, Sgoal); if (minV == null || (h != null && minV > h)) { minV = h; next = s; } } // Update hAdjusted for current state. if (minV != null) { hAdjusted(Sstart, minV + h(next, Sstart)); } break; /*case ChooseMethodStep.LRTAStar: * int Expansions = GetLocalSearchComputationLimit( ); * var P = LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss, * Expansions, sv, * ref this.Expansions, ref this.Generations, false, * Ops, HAdjusted, H, new InStateGoal<SS, DS>( LandmarkGoal ), Weight, false ); * if ( P == null ) { * next = null; * } else { * next = P.Actions.First.Value.PerformOn( Sstart, ss ).First( ); * } * break; * case ChooseMethodStep.RTAStar: * Expansions = GetLocalSearchComputationLimit( ); * P = LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss, * Expansions, sv, * ref this.Expansions, ref this.Generations, false, * Ops, HAdjusted, H, new InStateGoal<SS, DS>( LandmarkGoal ), Weight, true ); * if ( P == null ) { * next = null; * } else { * next = P.Actions.First.Value.PerformOn( Sstart, ss ).First( ); * } * break; * case ChooseMethodStep.AStar: * Expansions = GetLocalSearchComputationLimit( ); * P = LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss, * Expansions, sv, * ref this.Expansions, ref this.Generations, false, * Ops, null, H, new InStateGoal<SS, DS>( LandmarkGoal ), Weight, false ); * if ( P == null ) { * next = null; * } else { * next = P.Actions.First.Value.PerformOn( Sstart, ss ).First( ); * } * break;*/ case ChooseMethodStep.LSSLRTAStar: int Expansions = GetLocalSearchComputationLimit( ); var P = LSSLRTAStar <SS, DS> .LSSLRTAStarLookahead(Expansions, ss, Sstart, Sgoal, Ops, h0, ref Incumbant, ref this.Expansions, sv, tree, HLSS); if (P == null) { next = null; } else { next = P.Actions.First.Value.PerformOn(Sstart, ss).First( ); } break; } if (next == null) { return(null); } if (LLR) { LockedList.Remove(next); LLR = false; } /// Extract the path info. Operator <SS, DS> Op = null; foreach (var action in Ops) { if (action.IsValidOn(Sstart, ss, false) && action.PerformOn(Sstart, ss).First( ).Equals(next)) { Op = action; break; } } if (Op == null) { return(null); } else { return(Operator <SS, DS> .MakePath(Op)); } } } catch (InvalidOperationException) { return(null); } }