internal HeuristicSearchBase(HeuristicSearchBase <TFactor, TStep> source)
: this(source.AlgorithmName, source.From, source.To, source.StepComparer, source.NodeComparer, source.Converter, source.Expander)
{
_source = source;
IsReversed = source.IsReversed;
AlgorithmObserverFactory = source.AlgorithmObserverFactory;
}
/// <summary>
/// Determines whether the solution can be found.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <returns>true if the solution can be found; otherwise, false.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="InvalidOperationException">
/// The orderby clause is missing or <typeparamref name="TFactor"/> does not implement <see cref="IComparable{TFactor}"/> interface.
/// </exception>
public static bool Any <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
return(source.Run() != null);
}
public HeuristicSearchSelect(HeuristicSearchBase <TSource, TStep> source, Func <TSource, int, TFactor> selector)
: base(source.AlgorithmName, source.From, source.To, source.StepComparer, null, null, source.Expander)
{
_source = source;
_selector = selector;
IsReversed = source.IsReversed;
AlgorithmObserverFactory = source.AlgorithmObserverFactory;
}
internal HeuristicSearchSelectMany(HeuristicSearchBase <TSource, TStep> source,
Func <TSource, int, IEnumerable <TCollection> > collectionSelector, Func <TSource, TCollection, TFactor> factorSelector)
: base(source.AlgorithmName, source.From, source.To, source.StepComparer, null, null, source.Expander)
{
_source = source;
_collectionSelector = collectionSelector;
_factorSelector = factorSelector;
IsReversed = source.IsReversed;
AlgorithmObserverFactory = source.AlgorithmObserverFactory;
}
/// <summary>
/// Inverts the order of solution from <see cref="HeuristicSearchBase{TFactor, TStep}.From"/> to <see cref="HeuristicSearchBase{TFactor, TStep}.To"/>
/// to <see cref="HeuristicSearchBase{TFactor, TStep}.To"/> to <see cref="HeuristicSearchBase{TFactor, TStep}.From"/>.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <returns>An instance with type <typeparamref name="TFactor"/> as factor.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
public static HeuristicSearchBase <TFactor, TStep> Reverse <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
source.IsReversed = !source.IsReversed;
return(source);
}
/// <summary>
/// Returns the number of steps in solution, in <see cref="Int64"/>.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <returns>The number of steps in solution.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="InvalidOperationException">
/// The orderby clause is missing or <typeparamref name="TFactor"/> does not implement <see cref="IComparable{TFactor}"/> interface.
/// </exception>
public static long LongCount <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var lastNode = source.Run();
return(lastNode == null ? 0 : lastNode.Level + 1);
}
/// <summary>
/// Apply filter to current instance.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <param name="predicate">A function to test each source element and its index for a condition.</param>
/// <returns>The instance with appied filter.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null.</exception>
public static HeuristicSearchBase <TFactor, TStep> Where <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source, Func <TFactor, int, bool> predicate)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (predicate == null)
{
throw new ArgumentNullException(nameof(predicate));
}
return(new HeuristicSearchWhere <TFactor, TStep>(source, predicate));
}
/// <summary>
/// Apply black-listing filter to current instance by giving a <typeparamref name="TStep"/> collection.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <param name="collection">The collection as filter condition.</param>
/// <returns>The instance with appied filter.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collection"/> is null.</exception>
public static HeuristicSearchBase <TFactor, TStep> Except <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source, IEnumerable <TFactor> collection)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
return(new HeuristicSearchExcept <TFactor, TStep>(source, collection, null));
}
/// <summary>
/// Apply white-listing filter to current instance by giving a <typeparamref name="TStep"/> collection and specific comparer.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <param name="collection">The collection as filter condition.</param>
/// <param name="comparer">The specific comparer.</param>
/// <returns>The instance with appied filter.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collection"/> is null.</exception>
public static HeuristicSearchBase <TFactor, TStep> Contains <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source, IEnumerable <TFactor> collection, IEqualityComparer <TFactor> comparer)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
return(new HeuristicSearchContains <TFactor, TStep>(source, collection, comparer));
}
/// <summary>
/// Returns last step of the solution, or default value of <typeparamref name="TFactor"/> if solution is not found.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <returns>The last step of the solution.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="InvalidOperationException">
/// The orderby clause is missing or <typeparamref name="TFactor"/> does not implement <see cref="IComparable{TFactor}"/> interface.
/// </exception>
public static TFactor LastOrDefault <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var lastNode = source.Run();
if (lastNode == null)
{
return(default(TFactor));
}
return(source.IsReversed ? lastNode.TraceBack().Factor : lastNode.Factor);
}
/// <summary>
/// Returns last step of the solution.
/// </summary>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <returns>The last step of the solution.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> is null.</exception>
/// <exception cref="InvalidOperationException">Solution is not found.</exception>
public static TFactor Last <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var lastNode = source.Run();
if (lastNode == null)
{
throw new InvalidOperationException("Sequence contains no elements.");
}
return(source.IsReversed ? lastNode.TraceBack().Factor : lastNode.Factor);
}
internal static Node <TFactor, TStep> Run <TFactor, TStep>(this HeuristicSearchBase <TFactor, TStep> source)
{
Debug.WriteLine($"Searching path between {source.From} and {source.To} with {source.AlgorithmName}...");
var lastNode = default(Node <TFactor, TStep>);
var observerFactory = source.AlgorithmObserverFactory;
var observer = observerFactory != null?observerFactory.Create(source) : null;
switch (source.AlgorithmName)
{
case nameof(AStar):
lastNode = observer == null?AStar.Run(source) : AStar.Run(source, observer);
break;
case nameof(BestFirstSearch):
lastNode = observer == null?BestFirstSearch.Run(source) : BestFirstSearch.Run(source, observer);
break;
case nameof(IterativeDeepeningAStar):
lastNode = observer == null?IterativeDeepeningAStar.Run(source) : IterativeDeepeningAStar.Run(source, observer);
break;
case nameof(RecursiveBestFirstSearch):
lastNode = observer == null?RecursiveBestFirstSearch.Run(source) : RecursiveBestFirstSearch.Run(source, observer);
break;
default:
var algorithm = HeuristicSearch.RegisteredAlgorithms[source.AlgorithmName](source.AlgorithmName);
if (algorithm is IObservableAlgorithm && observer != null)
{
lastNode = (algorithm as IObservableAlgorithm).Run(source, observer);
}
else
{
lastNode = algorithm.Run(source);
}
break;
}
return(lastNode);
}
internal HeuristicSearchExcept(HeuristicSearchBase <TFactor, TStep> source, IEnumerable <TFactor> collection, IEqualityComparer <TFactor> comparer)
: base(source)
{
_collection = collection;
_comparer = comparer;
}
internal HeuristicSearchOrderBy(HeuristicSearchBase <TFactor, TStep> source, INodeComparer <TFactor, TStep> nodeComparer)
: base(source.AlgorithmName, source.From, source.To, source.StepComparer, nodeComparer, source.Converter, source.Expander)
{
IsReversed = source.IsReversed;
AlgorithmObserverFactory = source.AlgorithmObserverFactory;
}
IProgress <AlgorithmState <TFactor, TStep> > IAlgorithmObserverFactory <TStep> .Create <TFactor>(HeuristicSearchBase <TFactor, TStep> source)
{
var progress = new AlgorithmProgress <TFactor, TStep>();
OnCreated(progress);
return(progress);
}
/// <summary>
/// Select one or more factors used to evaluate with heuristic functions.
/// </summary>
/// <typeparam name="TSource">The source type of factor used to evaluate with heuristic function.</typeparam>
/// <typeparam name="TCollection">The type of the intermediate elements collected by the function represented by <paramref name="collectionSelector"/>.</typeparam>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <param name="collectionSelector">A projection function to apply to each element of the source.</param>
/// <param name="factorSelector">The selector to select factor from current instance.</param>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="collectionSelector"/> or <paramref name="factorSelector"/> is null.</exception>
/// <returns>An instance with type <typeparamref name="TFactor"/> as factor.</returns>
/// <remarks>Only the factor with lowest cost estimated by heuristic function will be considerd.</remarks>
public static HeuristicSearchBase <TFactor, TStep> SelectMany <TSource, TCollection, TFactor, TStep>(this HeuristicSearchBase <TSource, TStep> source, Func <TSource, IEnumerable <TCollection> > collectionSelector, Func <TSource, TCollection, TFactor> factorSelector)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (collectionSelector == null)
{
throw new ArgumentNullException(nameof(collectionSelector));
}
if (factorSelector == null)
{
throw new ArgumentNullException(nameof(factorSelector));
}
return(new HeuristicSearchSelectMany <TSource, TCollection, TFactor, TStep>(source, (s, i) => collectionSelector(s), factorSelector));
}
/// <summary>
/// Select one or more factors used to evaluate with heuristic functions.
/// </summary>
/// <typeparam name="TSource">The source type of factor used to evaluate with heuristic function.</typeparam>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <param name="selector">The selector with index argument to select factor from current instance.</param>
/// <returns>An instance with type <typeparamref name="TFactor"/> as factor.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
/// <remarks>Only the factor with lowest cost estimated by heuristic function will be considerd.</remarks>
public static HeuristicSearchBase <TFactor, TStep> SelectMany <TSource, TFactor, TStep>(this HeuristicSearchBase <TSource, TStep> source, Func <TSource, int, IEnumerable <TFactor> > selector)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (selector == null)
{
throw new ArgumentNullException(nameof(selector));
}
return(new HeuristicSearchSelectMany <TSource, TFactor, TStep>(source, selector));
}
internal HeuristicSearchWhere(HeuristicSearchBase <TFactor, TStep> source, Func <TFactor, int, bool> predicate)
: base(source)
{
_predicate = predicate;
}
/// <summary>
/// Select the factor used to evaluate with heuristic functions.
/// </summary>
/// <typeparam name="TSource">The source type of factor used to evaluate with heuristic function.</typeparam>
/// <typeparam name="TFactor">The type of factor used to evaluate with heuristic function. The type is projected from <typeparamref name="TStep"/>.</typeparam>
/// <typeparam name="TStep">The type of step of the problem.</typeparam>
/// <param name="source">The current instance.</param>
/// <param name="selector">The selector to select factor from current instance.</param>
/// <returns>An instance with type <typeparamref name="TFactor"/> as factor.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null.</exception>
public static HeuristicSearchBase <TFactor, TStep> Select <TSource, TFactor, TStep>(this HeuristicSearchBase <TSource, TStep> source, Func <TSource, TFactor> selector)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (selector == null)
{
throw new ArgumentNullException(nameof(selector));
}
return(new HeuristicSearchSelect <TSource, TFactor, TStep>(source, (s, i) => selector(s)));
}
