/// <summary>
/// Liefert den Wert der heuristischen Funktion für den übergebenen Knoten.
/// </summary>
/// <param name="node">Der Knoten, dessen Heuristik ermittelt werden soll.</param>
/// <param name="searchProblem">Das Problem, dass es zu lösen gilt.</param>
/// <param name="searchMethod">Die Suchmethode, die gerade abläuft.</param>
/// <returns>Gibt den Wert der Heuristik zurück.</returns>
public double GetHeuristicValue(OKSearchRoom.INode node, IHeuristicSearchProblem searchProblem, ISearchMethod searchMethod)
{
double result = 0;
if (searchProblem is ConstraintOptimizationProblem)
{
ConstraintConfiguration configuration = (ConstraintConfiguration)node.Data;
ConstraintOptimizationProblem optProblem = searchProblem as ConstraintOptimizationProblem;
if (optProblem.SolutionList.Count == 0)
{
return(configuration.GetCountDomainValues());
}
else
{
OptimizationConstraint optConstraint = optProblem.GetObjectiveFunction();
optConstraint.SetCurrentConfiguration(configuration);
IOperation operation = optConstraint.ObjectiveFunction;
if (operation.DoOperation(out result) != true)
{
return(-double.MaxValue);
}
else
{
//return configuration.GetCountDomainValues();
if (operation.GetType() == typeof(Minimum))
{
return(result + configuration.GetCountDomainValues());
}
//return configuration.GetCountDomainValues();
//return (configuration.GetCountDomainValues()+result);
//return (result + configuration.GetCountDomainValues());
//return (result + _objectiveConstraint.ObjectiveValue * configuration.GetCountDomainValues());
//return configuration.GetCountDomainValues();
//return -(_objectiveConstraint.ObjectiveValue - result) + configuration.GetCountDomainValues() * result;
//return -(_objectiveConstraint.ObjectiveValue - result) + configuration.GetCountDomainValues() * _objectiveConstraint.ObjectiveValue;
//return -node.Depth * (_objectiveConstraint.ObjectiveValue - result);
//return result - _objectiveConstraint.ObjectiveValue;
//return -node.Depth * (result - _objectiveConstraint.ObjectiveValue);
else
{
//return node.Depth * (_objectiveConstraint.ObjectiveValue - result);
return(configuration.GetCountDomainValues() - result);
}
}
}
}
return(result);
}
/// <summary>
/// Der Suchalgorithmus wird gestartet. Er kann nur beendet werden, indem
/// innerhalb der Methode des Eventhandlers Cancel auf true gesetzt wird.
/// Sonst endet die Suche mit dem Finden des Zielknotens, oder nach erfolglosem
/// Absuchen des gesamten Suchraums.
/// </summary>
protected override void Search()
{
//DateTime timeStamp = DateTime.Now;
INode[] generatedNodes;
PriorityQueue <double, INode> sortedNodes = new PriorityQueue <double, INode>();
//FibonacciHeap<double, INode> sortedNodes = new FibonacciHeap<double, INode>();
IHeuristicSearchProblem problem = (IHeuristicSearchProblem)_searchProblem;
while (ChooseNode())
{
if (_searchProblem.CompareNodes(_currentNode))
{
if (_searchProblem.OnFoundDestination(_currentNode, this))
{
return;
}
else
{
continue;
}
}
generatedNodes = _searchProblem.GenerateChildren(_currentNode, 0);
foreach (INode node in generatedNodes)
{
// Es wird hier die negative Heuristik genutzt, um bei einem pop zu erst den schlechtesten Knoten zu bekommen
sortedNodes.Push(-problem.HeuristicValue.GetHeuristicValue(node, (IHeuristicSearchProblem)_searchProblem, this), node);
}
while (sortedNodes.Count != 0)
{
INode node = sortedNodes.Pop();
_nodes.Push(node);
}
EmitSearchEvent(_nodes.Count);
if (_cancel)
{
_searchProblem.OnFoundNoneDestination();
return;
}
}
problem.OnFoundNoneDestination();
}
public double GetHeuristicValue(OKSearchRoom.INode node, IHeuristicSearchProblem searchProblem, OKSearchRoom.ISearchMethod searchMethod)
{
double heuristic = 0.0;
LloydPuzzleProblem puzzleProblem = searchProblem as LloydPuzzleProblem;
LloydPuzzleSituation sitDest = puzzleProblem.Destination.Data as LloydPuzzleSituation;
LloydPuzzleSituation sitNode = (LloydPuzzleSituation)node.Data;
int count = sitDest.Dimension * sitDest.Dimension;
for (int i = 0; i < count; i++)
{
heuristic += sitDest.GetDistance(i, sitNode.IndexOf(sitDest[i]));
}
return(heuristic);
}
public double GetHeuristicValue(OKSearchRoom.INode node, IHeuristicSearchProblem searchProblem, OKSearchRoom.ISearchMethod searchMethod)
{
QueenConstellation constellation = (QueenConstellation)node.Data;
return(constellation.LastQueenOccupations);
}
/// <summary>
/// nodocu
/// </summary>
protected override void Search()
{
//DateTime timeStamp = DateTime.Now;
int counter = 0;
int treshold = 150;
INode[] generatedNodes;
PriorityQueue <double, INode> sortedNodes = new PriorityQueue <double, INode>();
//FibonacciHeap<double, INode> sortedNodes = new FibonacciHeap<double, INode>();
IHeuristicSearchProblem problem = (IHeuristicSearchProblem)_searchProblem;
while (ChooseNode())
{
counter++;
// Wenn zu lange gesucht wurde, wird mal ein BestSearch angewandt
//TimeSpan time = DateTime.Now - timeStamp;
//if (time.Milliseconds > 200)
if (counter > treshold)
{
counter = 0;
//timeStamp = DateTime.Now;
foreach (INode node in _nodes)
{
// Es wird hier die negative Heuristik genutzt, um bei einem pop zu erst den schlechtesten Knoten zu bekommen
sortedNodes.Push(-problem.HeuristicValue.GetHeuristicValue(node, (IHeuristicSearchProblem)_searchProblem, this), node);
}
_nodes.Clear();
while (sortedNodes.Count != 0)
{
INode node = sortedNodes.Pop();
_nodes.Push(node);
}
}
if (_searchProblem.CompareNodes(_currentNode))
{
counter = 0;
treshold = 150;
if (_searchProblem.OnFoundDestination(_currentNode, this))
{
return;
}
else
{
continue;
}
}
generatedNodes = _searchProblem.GenerateChildren(_currentNode, 0);
foreach (INode node in generatedNodes)
{
// Es wird hier die negative Heuristik genutzt, um bei einem pop zu erst den schlechtesten Knoten zu bekommen
sortedNodes.Push(-problem.HeuristicValue.GetHeuristicValue(node, (IHeuristicSearchProblem)_searchProblem, this), node);
}
while (sortedNodes.Count != 0)
{
INode node = sortedNodes.Pop();
_nodes.Push(node);
}
EmitSearchEvent(_nodes.Count);
if (_cancel)
{
_searchProblem.OnFoundNoneDestination();
return;
}
}
problem.OnFoundNoneDestination();
}
/// <summary>
/// Konstruktor.
/// </summary>
/// <param name="searchProblem"></param>
public SoftHillClimbingFirstSearch(IHeuristicSearchProblem searchProblem) : base(searchProblem)
{
}
/// <summary>
/// Constructor for this algorithm.
/// </summary>
/// <param name="problem">The search problem to solve.</param>
public AStarSearch(IHeuristicSearchProblem problem) : base(problem)
{
_comparer = new HeuristicNodeComparer();
}
/// <summary>
/// Dem Konstruktor wird ein Suchproblem mit Heuristik übergeben.
/// </summary>
/// <param name="searchProblem">Stellt das Suchproblem mit Heuristik dar, auf welches das
/// Suchverfahren angewendet wird.</param>
public HeuristicSearchMethod(IHeuristicSearchProblem searchProblem)
{
_searchProblem = searchProblem;
_cancel = false;
_inspectedNodes = 0;
}
/// <summary>
/// Der Konstruktor.
/// </summary>
/// <param name="searchProblem"></param>
public AStarFirstSearch(IHeuristicSearchProblem searchProblem) : base(searchProblem)
{
_nodes = new OKPriorityQueues.PriorityQueue <double, INode>();
//_nodes = new OKPriorityQueues.FibonacciHeap<double, INode>();
}
/// <summary>
/// Der Konstruktor.
/// </summary>
/// <param name="searchProblem"></param>
public GreedyFirstSearch(IHeuristicSearchProblem searchProblem) : base(searchProblem)
{
_nodes = new PriorityQueue <double, INode>();
//_nodes = new FibonacciHeap<double, INode>();
}
public double GetHeuristicValue(OKSearchRoom.INode node, IHeuristicSearchProblem searchProblem, ISearchMethod searchMethod)
{
ConstraintConfiguration configuration = (ConstraintConfiguration)node.Data;
return(configuration.GetCountDomainValues());
}
