public void Resolve()
{
rubickCube.Apply();
Problem problem = new Problem(rubickCube,
new RubickSuccessorFunction(),
new RubickGoalTest(),
new RubickHeuristicFunction());
Search search = new IterativeDeepeningSearch();
//Search search = new AStarSearch(new GraphSearch());
SearchAgent agent = new SearchAgent(problem, search);
int iterations = -1;
ArrayList actions = agent.getActions();
Hashtable info = agent.getInstrumentation();
for (int i = 0; i < actions.Count; i++)
{
RubickMovementTypes move = (RubickMovementTypes)Enum.Parse(typeof(RubickMovementTypes), (string)actions[i]);
rubickCube.Transform(move);
}
//aStarSearchTree.Search(rubickCube);
//if (aStarSearchTree.result != null)
//{
// rubickCube = aStarSearchTree.result;
// iterations = aStarSearchTree.iterations;
//}
DispatchEvent(new RubickCubeResolvedOutputEvent((RubickColorMatrix)rubickCube.Clone(), iterations));
}
private void btnIDLS_Click(object sender, System.EventArgs e)
{
this.textBox1.Text = "EightPuzzleDemo Iterative DLS-->" + System.Environment.NewLine;
Problem problem = new Problem(random1,
new EightPuzzleSuccessorFunction(),
new EightPuzzleGoalTest());
Search search = new IterativeDeepeningSearch();
SearchAgent agent = new SearchAgent(problem, search);
printActions(agent.getActions());
printInstrumentation(agent.getInstrumentation());
}
private void btnIterativeDeeping_Click(object sender, System.EventArgs e)
{
this.textBox1.Text = "NQueensDemo Iterative DS -->" + System.Environment.NewLine;
Problem problem = new Problem(new NQueensBoard(8), new NQueensSuccessorFunction(), new NQueensGoalTest());
Search search = new IterativeDeepeningSearch();
SearchAgent agent = new SearchAgent(problem, search);
printActions(agent.getActions());
printInstrumentation(agent.getInstrumentation());
}
static void IDS(string input, SearchMode mode)
{
var nodeFactory = new DefaultNodeFactory();
var expander = new DummyNodeExpander <Node <State> >(nodeFactory);
var searcher = new IterativeDeepeningSearch(expander, mode);
var parser = new Parser(input);
var results = searcher.Search(nodeFactory.CreateNode(null, new InitAction(parser)));
var res = results.First();
Console.WriteLine($"Result:\r\n{res.Dump()}");
Console.WriteLine($"MaxDepth: {searcher.MaxDepthStat}");
Console.WriteLine($"ExpandedNodes: {searcher.ExpandedNodesStat}");
}
public void ShouldFail()
{
_states["A"].NextStatesList = new[] { _states["B"], _states["C"] };
_states["B"].NextStatesList = new[] { _states["D"] };
_states["C"].NextStatesList = new[] { _states["E"] };
_states["E"].NextStatesList = new[] { _states["F"] };
var problem = new DummyProblem(_states["A"]);
var search = new IterativeDeepeningSearch <DummyProblemState>();
var result = search.Search(problem).ToList();
Assert.Empty(result);
}
static void eightPuzzleIDLSDemo()
{
System.Console.WriteLine("\nEightPuzzleDemo Iterative DLS -->");
try
{
IProblem <EightPuzzleBoard, IAction> problem = new BidirectionalEightPuzzleProblem(random1);
ISearchForActions <EightPuzzleBoard, IAction> search = new IterativeDeepeningSearch <EightPuzzleBoard, IAction>();
SearchAgent <EightPuzzleBoard, IAction> agent = new SearchAgent <EightPuzzleBoard, IAction>(problem, search);
printActions(agent.getActions());
printInstrumentation(agent.getInstrumentation());
}
catch (Exception e)
{
throw e;
}
}
public void testIterativeDeepeningSearch() {
try {
Problem problem = new Problem(new NQueensBoard(8),
NQueensFunctionFactory.getIActionsFunction(),
NQueensFunctionFactory.getResultFunction(),
new NQueensGoalTest());
Search search = new IterativeDeepeningSearch();
SearchAgent agent = new SearchAgent(problem, search);
List<Action> actions = agent.getActions();
assertCorrectPlacement(actions);
Assert.assertEquals("3656", agent.getInstrumentation().getProperty(
"nodesExpanded"));
} catch (Exception e) {
e.printStackTrace();
Assert.fail("Exception should not occur");
}
}
static void nQueensWithIterativeDeepeningSearch()
{
System.Console.WriteLine("\nNQueensDemo Iterative DS -->");
try
{
IProblem <NQueensBoard, QueenAction> problem =
NQueensFunctions.createIncrementalFormulationProblem(boardSize);
ISearchForActions <NQueensBoard, QueenAction>
search = new IterativeDeepeningSearch <NQueensBoard, QueenAction>();
SearchAgent <NQueensBoard, QueenAction>
agent = new SearchAgent <NQueensBoard, QueenAction>(problem, search);
System.Console.WriteLine();
printActions(agent.getActions());
printInstrumentation(agent.getInstrumentation());
}
catch (Exception e)
{
throw e;
}
}
public void RandomBoardSearchTest()
{
var sizes = new[]
{
new { RowCount = 2, ColumnCount = 2 },
new { RowCount = 2, ColumnCount = 3 },
new { RowCount = 3, ColumnCount = 2 },
new { RowCount = 3, ColumnCount = 3 },
new { RowCount = 4, ColumnCount = 2 },
new { RowCount = 2, ColumnCount = 4 },
//new { RowCount = 4, ColumnCount = 4 },
};
foreach (var size in sizes)
{
for (int i = 0; i < 3; i++)
{
var problem = new EightPuzzleProblem(Board.GenerateSolvableBoard(size.RowCount, size.ColumnCount));
var result = problem.CreateDefaultSolver().Search(problem).ToList();
Assert.NotEmpty(result);
}
}
foreach (var size in sizes.Take(3))
{
for (int i = 0; i < 3; i++)
{
var problem = new EightPuzzleProblem(Board.GenerateSolvableBoard(size.RowCount, size.ColumnCount));
var result = new IterativeDeepeningSearch <EightPuzzleState>().Search(problem).ToList();
Assert.NotEmpty(result);
}
}
}
public aima.core.search.framework.Search GetSearch(Object owner, IContextLookup globalVars, HeuristicFunction objHeuristicFunction)
{
aima.core.search.framework.Search toReturn;
QueueSearch objQueueSearch;
switch (QueueSearchType)
{
case QueueSearchType.TreeSearch:
objQueueSearch = new TreeSearch();
break;
default:
objQueueSearch = new GraphSearch();
break;
}
switch (AlgorithmType)
{
case SearchAlgorithmType.KnownInformed:
switch (KnownInformedAlgorithm)
{
case KnownInformedSearch.GreedyBestFirst:
toReturn = new GreedyBestFirstSearch(objQueueSearch, objHeuristicFunction);
break;
case KnownInformedSearch.RecursiveGreedyBestFirst:
toReturn = new RecursiveBestFirstSearch(new GreedyBestFirstEvaluationFunction(objHeuristicFunction));
break;
case KnownInformedSearch.RecursiveAStar:
toReturn = new RecursiveBestFirstSearch(new AStarEvaluationFunction(objHeuristicFunction));
break;
case KnownInformedSearch.HillClimbing:
toReturn = new HillClimbingSearch(objHeuristicFunction);
break;
case KnownInformedSearch.SimulatedAnnealing:
toReturn = new SimulatedAnnealingSearch(objHeuristicFunction);
break;
default:
toReturn = new AStarSearch(objQueueSearch, objHeuristicFunction);
break;
}
break;
case SearchAlgorithmType.KnownUninformed:
switch (KnownUninformedAlgorithm)
{
case KnownUninformedSearch.DepthFirst:
toReturn = new DepthFirstSearch(objQueueSearch);
break;
case KnownUninformedSearch.DepthLimited:
toReturn = new DepthLimitedSearch(DepthLimit);
break;
case KnownUninformedSearch.IterativeDeepening:
toReturn = new IterativeDeepeningSearch();
break;
case KnownUninformedSearch.UniformCost:
toReturn = new UniformCostSearch(objQueueSearch);
break;
case KnownUninformedSearch.Bidirectional:
toReturn = new BidirectionalSearch();
break;
default:
toReturn = new BreadthFirstSearch(objQueueSearch);
break;
}
break;
default:
toReturn = CustomSearchAlgorithm.EvaluateTyped(owner, globalVars);
break;
}
return(toReturn);
}
public void EightPuzzleTest()
{
// Number of trials to run
int N = 100;
// Maximum depth of the solution
int dmax = 10;
// Now we define the search algorithm and the type of node expansion. Russell & Norvig discuss
// two type of expansion strategies: tree search and graph search. One will avoid cycles in the search
// space and the other will not.
//
// They state that a tree search was used to generate Figure 4.8;
var expander = new InstrumentedNodeExpander <Direction, EightPuzzleBoard, EightPuzzleNode, IntegerCost>(new EightPuzzleNodeExpander());
var treeSearch = new TreeSearch <Direction, EightPuzzleBoard, EightPuzzleNode, IntegerCost>(expander);
var ids = new IterativeDeepeningSearch <Direction, EightPuzzleBoard, EightPuzzleNode, IntegerCost>(treeSearch, dmax);
var aStarH1 = new AStarSearch <Direction, EightPuzzleBoard, EightPuzzleNode, IntegerCost>(treeSearch, () => new QueueAdapter <EightPuzzleNode, IntegerCost>());
var aStarH2 = new AStarSearch <Direction, EightPuzzleBoard, EightPuzzleNode, IntegerCost>(treeSearch, () => new QueueAdapter <EightPuzzleNode, IntegerCost>());
// Depth runs from 0 to dmax
int[,] d = new int[dmax + 1, 3];
int[,] n = new int[dmax + 1, 3];
for (int _d = 1; _d <= dmax; _d++)
{
for (int i = 0; i < N; i++)
{
// Invoke the search on the problem with a particular starting state. Scramble creates a new instance
var initialState = EightPuzzleBoard.GOAL.Scramble(_d);
{
expander.ClearMetrics();
var solution = ids.Search(problem_none, new EightPuzzleBoard(initialState));
var depth = solution.Count() - 1;
System.Diagnostics.Trace.WriteLine("IDS Solution has depth " + depth + " and expanded " + expander[IntrumentedParameters.NODES_EXPANDED] + " nodes");
d[depth, 0] += 1;
n[depth, 0] += expander[IntrumentedParameters.NODES_EXPANDED];
}
{
expander.ClearMetrics();
var solution = aStarH1.Search(problem_h1, new EightPuzzleBoard(initialState));
var depth = solution.Count() - 1;
System.Diagnostics.Trace.WriteLine("A* (h1) Solution has depth " + depth + " nodes and expanded " + expander[IntrumentedParameters.NODES_EXPANDED] + " nodes");
d[depth, 1] += 1;
n[depth, 1] += expander[IntrumentedParameters.NODES_EXPANDED];
// PrintSolution(solution);
}
{
expander.ClearMetrics();
var solution = aStarH2.Search(problem_h2, new EightPuzzleBoard(initialState));
var depth = solution.Count() - 1;
System.Diagnostics.Trace.WriteLine("A* (h2) Solution has depth " + depth + " nodes and expanded " + expander[IntrumentedParameters.NODES_EXPANDED] + " nodes");
d[depth, 2] += 1;
n[depth, 2] += expander[IntrumentedParameters.NODES_EXPANDED];
// PrintSolution(solution);
}
}
}
Trace.WriteLine("| Search Cost Branching Factor |");
Trace.WriteLine("+--+---------+--------+--------++---------+--------+--------+");
Trace.WriteLine("| d| IDS | A*(h1) | A*(h2) || IDS | A*(h1) | A*(h2) |");
Trace.WriteLine("+--+---------+--------+--------++---------+--------+--------+");
for (int i = 1; i <= dmax; i++)
{
var bf0 = ComputeBranchingFactor((float)n[i, 0] / (float)d[i, 0], i);
var bf1 = ComputeBranchingFactor((float)n[i, 1] / (float)d[i, 1], i);
var bf2 = ComputeBranchingFactor((float)n[i, 2] / (float)d[i, 2], i);
Trace.WriteLine(String.Format("|{0,2}|{1,-8} |{2,7} |{3,7} ||{4,8:0.00} |{5,7:0.00} |{6,7:0.00} |", i,
n[i, 0] / Math.Max(d[i, 0], 1), n[i, 1] / Math.Max(d[i, 1], 1), n[i, 2] / Math.Max(d[i, 2], 1), bf0, bf1, bf2));
}
Trace.WriteLine("+--+---------+--------+--------++---------+--------+--------+");
}
//ALGORITHMS
private void Button_Click_1(object sender, RoutedEventArgs e)
{
if (task != null && task.Status == TaskStatus.Running)
{
cancelTokenSource.Cancel();
while (task.Status == TaskStatus.Running)
{
Thread.Sleep(10);
}
return;
}
foreach (Node n in graph.Nodes)
{
n.Background = unmarkedNode;
}
IAlgorithm algorithm = null;
string alg = cbAlgorithm.SelectedItem.ToString().Split(':')[1].Trim();
switch (alg)
{
case "Breadth-first search":
{
BreadthFirstSearch bfs = new BreadthFirstSearch();
bfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = bfs;
break;
}
case "Depth-first search":
{
DepthFirstSearch dfs = new DepthFirstSearch();
dfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = dfs;
break;
}
case "Depth-limited search":
{
DepthLimitedSearch dfs = new DepthLimitedSearch();
dfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString(),
tbDepthLimit.Text.Length == 0 ? 0 : int.Parse(tbDepthLimit.Text), out int d);
algorithm = dfs;
break;
}
case "Uniform-cost search":
{
UniformCostSearch dfs = new UniformCostSearch();
dfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = dfs;
break;
}
case "Iterative deepening depth-first search":
{
IterativeDeepeningSearch ids = new IterativeDeepeningSearch();
ids.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = ids;
break;
}
case "Greedy best-first search":
{
GreedyBestFirstSearch dfs = new GreedyBestFirstSearch();
dfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = dfs;
break;
}
case "A* search":
{
AstarSearch dfs = new AstarSearch();
dfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = dfs;
break;
}
case "Memory-bounded heuristic search":
{
MemoryBoundedHeuristicSearch dfs = new MemoryBoundedHeuristicSearch();
dfs.Search(graph.GetNodeByName(cbSearchFrom.SelectedItem?.ToString()),
cbSearchFor.SelectedItem?.ToString());
algorithm = dfs;
break;
}
default: break;
}
if (algorithm == null)
{
return;
}
cancelTokenSource = new CancellationTokenSource();
task = new Task(() =>
{
DateTime dateTime;
foreach (Node n in algorithm.VisitedNodes)
{
double delay = 0;
this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
{
delay = sliderAnimationSpeed.Value;
}));
dateTime = DateTime.Now;
while (dateTime.AddSeconds(delay) > DateTime.Now)
{
if (cancelTokenSource.IsCancellationRequested)
{
return;
}
Thread.Sleep(10);
}
this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
{
if (n.Background == markedNode)//iterative deepening on stage
{
foreach (Node nn in graph.Nodes)
{
nn.Background = unmarkedNode;
}
}
n.Background = markedNode;
}));
}
if (algorithm.Result != null)
{
this.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
{
algorithm.Result.Background = goalNode;
}));
}
}, cancelTokenSource.Token);
task.Start();
}
/**
* Creates a search instance.
*
* @param strategy
* search strategy. See static constants.
* @param qSearchImpl
* queue search implementation: e.g. {@link #TREE_SEARCH}, {@link #GRAPH_SEARCH}
*
*/
public ISearchForActions <S, A> createSearch <S, A>(int strategy, int qSearchImpl, IToDoubleFunction <Node <S, A> > h)
{
QueueSearch <S, A> qs = null;
ISearchForActions <S, A> result = null;
switch (qSearchImpl)
{
case TREE_SEARCH:
qs = new TreeSearch <S, A>();
break;
case GRAPH_SEARCH:
qs = new GraphSearch <S, A>();
break;
case GRAPH_SEARCH_RED_FRONTIER:
qs = new GraphSearchReducedFrontier <S, A>();
break;
case GRAPH_SEARCH_BFS:
qs = new GraphSearchBFS <S, A>();
break;
case BIDIRECTIONAL_SEARCH:
qs = new BidirectionalSearch <S, A>();
break;
}
switch (strategy)
{
case DF_SEARCH:
result = new DepthFirstSearch <S, A>(qs);
break;
case BF_SEARCH:
result = new BreadthFirstSearch <S, A>(qs);
break;
case ID_SEARCH:
result = new IterativeDeepeningSearch <S, A>();
break;
case UC_SEARCH:
result = new UniformCostSearch <S, A>(qs);
break;
case GBF_SEARCH:
result = new GreedyBestFirstSearch <S, A>(qs, h);
break;
case ASTAR_SEARCH:
result = new AStarSearch <S, A>(qs, h);
break;
case RBF_SEARCH:
result = new RecursiveBestFirstSearch <S, A>(new AStarSearch <S, A> .EvalFunction(h));
break;
case RBF_AL_SEARCH:
result = new RecursiveBestFirstSearch <S, A>(new AStarSearch <S, A> .EvalFunction(h), true);
break;
case HILL_SEARCH:
result = new HillClimbingSearch <S, A>(h);
break;
}
return(result);
}
