public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
{
Debug.WriteLine("LINQ Expression Stack: {0}", source);
var nc = source.NodeComparer.FactorOnlyComparer;
var sc = source.StepComparer;
var nexts = new List <Node <TFactor, TStep> >(source.ConvertToNodes(source.From, 0));
if (nexts.Count == 0)
{
return(observer.NotFound());
}
var visited = new HashSet <TStep>(sc);
var sortAt = 0;
while (nexts.Count - sortAt > 0)
{
var best = observer.InProgress(nexts[sortAt], nexts.GetRange(sortAt, nexts.Count - sortAt)); // nexts.First();
var sortAll = false;
if (sc.Equals(best.Step, source.To))
{
return(observer.Found(best, nexts.GetRange(sortAt, nexts.Count - sortAt)));
}
sortAt++; // nexts.RemoveAt(0);
foreach (var next in source.Expands(best.Step, best.Level, visited.Add))
{
next.Previous = best;
if (sc.Equals(next.Step, source.To))
{
return(observer.Found(next, nexts.GetRange(sortAt, nexts.Count - sortAt)));
}
sortAll = sortAll || nc.Compare(nexts[nexts.Count - 1], next) > 0;
nexts.Add(next);
Debug.WriteLine($"{best.Step}\t{best.Level} -> {next.Step}\t{next.Level}");
}
if (sortAll)
{
nexts.Sort(sortAt, nexts.Count - sortAt, nc);
}
}
return(observer.NotFound());
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
var open = new List <Node <TFactor, TStep> >(source.ConvertToNodes(source.From, 0));
if (open.Count == 0)
{
return(null);
}
open.Sort(source.NodeComparer);
var closed = new HashSet <TStep>(source.StepComparer);
var sortAt = 0;
while (open.Count > 0)
{
var current = open[sortAt];
var hasNext = false;
if (source.StepComparer.Equals(current.Step, source.To))
{
return(current);
}
sortAt++; // open.RemoveAt(0);
closed.Add(current.Step);
foreach (var next in source.Expands(current.Step, current.Level))
{
if (closed.Contains(next.Step))
{
continue;
}
if (open.Find(step => source.StepComparer.Equals(next.Step, step.Step)) == null)
{
Debug.WriteLine($"{current.Step}\t{current.Level} -> {next.Step}\t{next.Level}");
next.Previous = current;
open.Add(next);
hasNext = true;
}
}
if (hasNext)
{
open.Sort(sortAt, open.Count - sortAt, source.NodeComparer);
}
}
return(null);
}
public static HeuristicSearchBase <Point, Point> ApplyHeuristicFunction(HeuristicSearchBase <Point, Point> queryable, string[] heuristicNames)
{
var orderBy = default(HeuristicSearchOrderBy <Point, Point>);
var goal = queryable.To;
switch (heuristicNames.FirstOrDefault())
{
case nameof(PointExtensions.GetChebyshevDistance):
orderBy = queryable.OrderBy(p => p.GetChebyshevDistance(goal));
break;
case nameof(PointExtensions.GetEuclideanDistance):
orderBy = queryable.OrderBy(p => p.GetEuclideanDistance(goal));
break;
case nameof(PointExtensions.GetManhattanDistance):
orderBy = queryable.OrderBy(p => p.GetManhattanDistance(goal));
break;
default:
return(queryable);
}
foreach (var heuristicName in heuristicNames.Skip(1).Take(2))
{
switch (heuristicName)
{
case nameof(PointExtensions.GetChebyshevDistance):
orderBy = orderBy.ThenBy(p => p.GetChebyshevDistance(goal));
break;
case nameof(PointExtensions.GetEuclideanDistance):
orderBy = orderBy.ThenBy(p => p.GetEuclideanDistance(goal));
break;
case nameof(PointExtensions.GetManhattanDistance):
orderBy = orderBy.ThenBy(p => p.GetManhattanDistance(goal));
break;
default:
continue;
}
}
return(orderBy);
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
var nexts = new List <Node <TFactor, TStep> >(source.ConvertToNodes(source.From, 0));
if (nexts.Count == 0)
{
return(null);
}
var visited = new HashSet <TStep>(source.StepComparer);
var sortAt = 0;
while (nexts.Count > 0)
{
var best = nexts[sortAt]; // nexts.First();
var hasNext = false;
if (source.StepComparer.Equals(best.Step, source.To))
{
return(best);
}
sortAt++; // nexts.RemoveAt(0);
foreach (var next in source.Expands(best.Step, best.Level, visited.Add))
{
Debug.WriteLine($"{best.Step}\t{best.Level} -> {next.Step}\t{next.Level}");
next.Previous = best;
nexts.Add(next);
hasNext = true;
}
if (hasNext)
{
nexts.Sort(sortAt, nexts.Count - sortAt, source.NodeComparer.FactorOnlyComparer);
}
}
return(null);
}
internal ObservableRecursiveBestFirstSearch(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
: base(source)
{
_observer = observer;
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
return(new RecursiveBestFirstSearch <TFactor, TStep>(source).Run());
}
internal IterativeDeepeningAStarBase(HeuristicSearchBase <TFactor, TStep> source)
{
Source = source;
}
internal RecursiveBestFirstSearchBase(HeuristicSearchBase <TFactor, TStep> source)
{
Source = source;
NodeComparer = source.NodeComparer.FactorOnlyComparer;
}
internal ObservableIterativeDeepeningAStar(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
: base(source)
{
_observer = observer;
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
{
Debug.WriteLine("LINQ Expression Stack: {0}", source);
var nc = source.NodeComparer;
var sc = source.StepComparer;
var open = new List <Node <TFactor, TStep> >(source.ConvertToNodes(source.From, 0));
if (open.Count == 0)
{
return(observer.NotFound());
}
open.Sort(nc);
#if HASHSET_AS_CLOSED_LIST
Debug.WriteLine($"Using {typeof(HashSet<TStep>).Name} as closed list.");
var closed = new HashSet <TStep>(sc);
#endif
var sortAt = 0;
while (open.Count - sortAt > 0)
{
var current = observer.InProgress(open[sortAt], open.GetRange(sortAt, open.Count - sortAt));
var sortAll = false;
if (sc.Equals(current.Step, source.To))
{
return(observer.Found(current, open.GetRange(sortAt, open.Count - sortAt)));
}
sortAt++;
#if HASHSET_AS_CLOSED_LIST
closed.Add(current.Step);
#endif
foreach (var next in source.Expands(current.Step, current.Level))
{
// 1st if: search in closed list.
// 2nd if: search in open list.
#if HASHSET_AS_CLOSED_LIST
if (closed.Contains(next.Step))
{
continue;
}
#else
if (open.FindLastIndex(sortAt - 1, step => sc.Equals(next.Step, step.Step)) != -1)
{
continue;
}
#endif
if (open.FindIndex(sortAt, step => sc.Equals(next.Step, step.Step)) == -1)
{
next.Previous = current;
if (sc.Equals(next.Step, source.To))
{
return(observer.Found(next, open.GetRange(sortAt, open.Count - sortAt)));
}
sortAll = sortAll || nc.Compare(open[open.Count - 1], next) > 0;
open.Add(next);
Debug.WriteLine($"{current.Step}\t{current.Level} -> {next.Step}\t{next.Level}");
}
}
if (sortAll)
{
open.Sort(sortAt, open.Count - sortAt, nc);
}
}
return(observer.NotFound());
}
Node <TFactor, TStep> IObservableAlgorithm.Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
{
return(Run(source, observer));
}
Node <TFactor, TStep> IAlgorithm.Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
return(Run(source));
}
public static IEnumerable <TResult> Run <TResult, TStep>(HeuristicSearchBase <TResult, TStep> source)
{
return(new IterativeDeepeningAStar <TResult, TStep>(source));
}
IProgress <AlgorithmState <TFactor, Point> > IAlgorithmObserverFactory <Point> .Create <TFactor>(HeuristicSearchBase <TFactor, Point> source)
{
var progress = new AlgorithmObserver <TFactor>();
Details.Clear();
progress.Callback = ProgressCallback;
return(progress);
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
Debug.WriteLine("LINQ Expression Stack: {0}", source);
return(new RecursiveBestFirstSearch <TFactor, TStep>(source).Run());
}
internal static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
Debug.WriteLine("LINQ Expression Stack: {0}", source);
return(new IterativeDeepeningAStar <TFactor, TStep>(source).Run());
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
{
Debug.WriteLine("LINQ Expression Stack: {0}", source);
return(new ObservableRecursiveBestFirstSearch <TFactor, TStep>(source, observer).Run());
}
internal static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source, IProgress <AlgorithmState <TFactor, TStep> > observer)
{
Debug.WriteLine("LINQ Expression Stack: {0}", source);
return(new ObservableIterativeDeepeningAStar <TFactor, TStep>(source, observer).Run());
}
public static IEnumerable <TResult> Run <TResult, TStep>(HeuristicSearchBase <TResult, TStep> source)
{
return(new RecursiveBestFirstSearch <TResult, TStep>(source));
}
public static Node <TFactor, TStep> Run <TFactor, TStep>(HeuristicSearchBase <TFactor, TStep> source)
{
return(new IterativeDeepeningAStar <TFactor, TStep>(source).Run());
}
