view release on metacpan or  search on metacpan

README  view on Meta::CPAN

  * str_function (str_function above)

      This function returns a *unique* string representation of this node. 
      Uniqueness is required for SMA* to work properly.
    

  * max states allowed in memory (max_states_in_queue above)

      An integer indicating the maximum number of expanded nodes to 
      hold in memory at any given time.
    

  * maximum cost (MAX_COST above)

      An integer indicating the maximum cost, beyond which nodes will not be 
      expanded.



DESCRIPTION

Overview

Memory-bounded A* search (or SMA* search) addresses some of the limitations of 
conventional A* search, by bounding the amount of space required to perform a 
shortest-path search. This module is an implementation of SMA*, which was first 
introduced by Stuart Russell in 1992. SMA* is a more efficient variation of the 
original MA* search introduced by Chakrabarti et al. in 1989. See references below.

Motivation and Comparison to A* Search

A* search

A* Search is an optimal and complete algorithm for computing a sequence of 
operations leading from a system's start-state (node) to a specified goal. In 
this context, optimal means that A* search will return the shortest possible 
sequence of operations (path) leading to the goal, and complete means that A* will 
always find a path to the goal if such a path exists.

In general, A* search works using a calculated cost function on each node 
along a path, in addition to an admissible heuristic estimating the distance 
from that node to the goal. The cost is calculated as:

f(n) = g(n) + h(n)

Where:

    

   * n is a state (node) along a path
    

   * g(n) is the total cost of the path leading up to n
    

   * h(n) is the heuristic function, or estimated cost of the path from n 
      to the goal node.

The to be admissible, the heuristic must never over-estimate the distance 
from the node to the goal. If the heuristic is set to zero, A* search reduces 
to Branch and Bound search.

For a given heuristic function, it can be shown that A* search is optimally 
efficient, meaning that, in its calculation of the shortest path, it expands 
fewer nodes in the search space than any other algorithm.

The space complexity of A* search is bounded by an exponential of the 
branching factor of the search-space and the length of the longest path 
examined during the search.  This is can be a problem particularly if the 
branching factor is large, as the algorithm may run out of memory.


SMA* Search

SMA* search addresses the possibility of running out of memory during search by 
pruning the portion of the search-space that is being examined. It relies on the 
pathmax, or monotonicity constraint on f(n) to remove the shallowest of the 
highest-cost nodes from the search queue when there is no memory left to 
expand new nodes. It records the best costs of the pruned nodes within their 
antecedent nodes to ensure that crucial information about the search space is not 
lost. To facilitate this mechanism, the search queue is best maintained as a 
search-tree of search-trees ordered by cost and depth, respectively.

The pruning of the search queue allows SMA* search to utilize all available 
memory for search without any danger of overflow. It can, however, make SMA* 
search significantly slower than a theoretical unbounded-memory search, due to 
the extra bookkeeping it must do, and because nodes may need to be re-expanded 
(the overall number of node expansions may increase).

It can be shown that of the memory-bounded variations of A* search, such MA*, 
IDA*, Iterative Expansion, etc., SMA* search expands the least number of nodes 
on average. However, for certain classes of problems, guaranteeing optimality 
can be costly. This is particularly true in solution spaces where:

    * the branching factor of the search space is large
    * there are multiple equivalent optimal solutions (or shortest paths)

For solution spaces with these characteristics, stochastic methods or 
approximation algorithms such as Simulated Annealing can provide a massive 
reduction in time and space requirements, while introducing a tunable 
probability of producing a sub-optimal solution.



METHODS

new()

Creates a new SMA* search object.

start_search()

Initiates a memory-bounded search. You must pass a log_function for recording 
current status, a function that returns a *unique* string representing a node in 
the search-space, a maximum number of expanded states to store in the queue, and a 
maximum cost value, beyond which the search will cease.

state_eval_func()

Sets/gets the function that returns the cost of this node in the 
search space.

state_goal_p_func()

Sets/gets the function that returns 1 if the node is a goal node, or 
0 otherwise.

state_num_successors_func()

Sets/gets the function that returns the number of successors of 
this node.

state_successors_iterator()

Sets/gets the function that returns the next successor of 
this node.

state_get_data_func()

Sets/gets the function that returns a string representation 
of this node.

show_prog_func()

sets/gets the callback function for displaying the progress of the 
search. It can be an empty callback if you do not need this output.

EXPORT

None by default.

SEE ALSO

Russell, Stuart. (1992) "Efficient Memory-bounded Search Methods" Proceedings 
of the 10th European conference on Artificial intelligence, pp. 1-5

Chakrabarti, P. P., Ghose, S., Acharya, A., and de Sarkar, S. C. (1989) "Heuristic 
search in restricted memory" Artificial Intelligence Journal, 41, pp. 197-221.

AUTHOR

Matthias Beebe, <mbeebe@cpan.org>


INSTALLATION

To install this module type the following:

   perl Makefile.PL
   make
   make test
   make install

DEPENDENCIES

This module requires these other modules and libraries:

  Tree::AVL
  Test::More

COPYRIGHT AND LICENCE

Copyright (C) 2010 by Matthias Beebe

This library is free software; you can redistribute it and/or modify it 
under the same terms as Perl itself, either Perl version 5.10.0 or, at 
your option, any later version of Perl 5 you may have available.