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