Class Index

A B C D E F G H I J L M N P R S T U W

A

AbstractNode<A, S, N extends AbstractNode<A, S, N>>	Basic implementation of the interface `Node`.
ActionFunction<A, S>	Interface that defines an action function that computes applicable actions for a given state.
ActionStateTransitionFunction<A, S>	Interface to define a transition function that takes an action and a concrete state and returns the new state.
ADStarForward<A, S, C extends Comparable<C>, N extends ADStarNode<A, S, C, N>>	Iterative implementation of the forward Anytime Dynamic A* (AD*-f) search algorithm.
ADStarForward.Iterator	Internal iterator that implements all the logic of the A* search
ADStarNode<A, S, C extends Comparable<C>, N extends ADStarNode<A, S, C, N>>	Implementation of `Node` to be used with the AD* algorithm, implemented in `ADStarForward`.
ADStarNode.Key<C extends Comparable<C>>	Inner class defining the key of the node, which depends on the values of G and V.
ADStarNodeExpander<A, S, C extends Comparable<C>, N extends ADStarNode<A, S, C, N>>	This class is an implementation of `NodeExpander` for nodes of type `ADStarNode`.
ADStarNodeFactory<A, S, C extends Comparable<C>>	The ADStarNodeBuilder is used for instantiate new `ADStarNodeImpl`.
ADStarNodeImpl<A, S, C extends Comparable<C>>	Interface defining the basic operations for `Node` to be used with `ADStarForward`.
ADStarNodeUpdater<A, S, C extends Comparable<C>>	The ADStarNodeUpdater is used by the `ADStarForward` algorithm to update the G and V values of the `ADStarNodeImpl` explored by the algorithm.
Algorithm<A, S, N extends Node<A, S, N>>	Abstract class implemented by each search algorithm.
Algorithm.SearchListener<N>
Algorithm.SearchResult	Holds information about the search process.
AnnealingSearch<A, S, N extends HeuristicNode<A, S, Double, N>>	Implementation of the simulated annealing search that is a probabilistic technique for approximating the global optimum of a given function.
AnnealingSearch.AcceptanceProbability	Interface to compute the acceptance probability.
AnnealingSearch.ASIterator
AnnealingSearch.SuccessorFinder<A, S, N extends Node<A, S, N>>	Interface to find the successor of a node.
ASCIIMazeVisualizer
AStar<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>	Implementation of the A* algorithm.
AStar.Iterator	Internal iterator that implements all the logic of the A* search

B

BellmanFord<A, S, C extends Comparable<C>, N extends CostNode<A, S, C, N>>	Optimized implementation of the Bellman-Ford algorithm.
BellmanFord.Iterator	Bellman-Ford iterator.
BinaryFunction<T>	A binary operation takes two elements of the same type and combines them returning an element of the same type.
BinaryOperation<E extends Comparable<E>>	A implementation of `BinaryFunction` used to define a custom cost algebra that also has the following definitions: identity element (AI = A) maximum element (AM = M)
BlueprintsGraphMultiobjectiveSearch	Simple example that loads a GraphML example graph from GitHub, loads it with the Blueprints API and then solves the multiobjective problem with Hipster A full description of the problem is published on Hipster's wiki.
BlueprintsHipsterDirectedGraphAdapter	Simple adapter implementation between a Hipster graph and a Blueprints graph.
BlueprintsHipsterGraphAdapter	Simple graph adapter between a Blueprints graph and a HipsterGraph.
BreadthFirstSearch<A, S, N extends Node<A, S, N>>	Breadth First Search (BFS) implementation.
BreadthFirstSearch.Iterator	Implements all the BFS search logic as an iterator

C

CostFunction<A, S, C extends Comparable<C>>	The cost function evaluates a transition between states.
CostNode<A, S, C extends Comparable<C>, N extends CostNode<A, S, C, N>>	Defines a node which stores an attribute for the cost, extending the interface of a basic node `Node`.

D

DepthFirstSearch<A, S, N extends Node<A, S, N>>	Depth First Search (DFS) is a blind algorithm that performs an exploration of the graph in a way that always reaches the deepest node before backtracking.
DepthFirstSearch.Iterator	DFS iterator used to expand always the deepest non-visited node.
DepthFirstSearch.StackFrameNode
DepthLimitedSearch<A, S, N extends Node<A, S, N>>	Copyright 2015 Centro de Investigación en Tecnoloxías da Información (CITIUS), University of Santiago de Compostela (USC).
DirectedEdge<V, E>
DirectedGraphSearchExample	Example that creates a `HipsterDirectedGraph`, creates a search problem to be used with Hipster search iterators and performs a search using the Dijkstra algorithm.

E

EightPuzzleProblemExample	Example of the N-Puzzle (3x3 tiles) search problem solved with the A* algorithm.
EightQueensProblemExample	Example using the N-Queens problem (size 8x8) solved using the Hill Climbing and Enforced Hill Climbing algorithms.
EightQueensProblemExampleWithAnnealingSearch	Example using the N-Queens problem (size 8x8) solved using the Annealing search.

F

F	This class contains a very limited set of functions to process iterables and iterators in a lazy way.
FibonacciHeap<T>	Author: Keith Schwarz ([email protected]) An implementation of a priority queue backed by a Fibonacci heap, as described by Fredman and Tarjan.
FibonacciHeap.Entry<T>
Function<E, V>

G

GraphBuilder<V, E>	Graph builder assistant to create a Hipster graph.
GraphBuilder.Vertex1
GraphBuilder.Vertex1.Vertex2
GraphEdge<V, E>	Hipster graph edge implementation to represent edges (or arcs) of a directed or undirected graph.
GraphEdge.Type
GraphSearchProblem	Builder to generate a `SearchProblem` but using a HipsterGraph.
GraphSearchProblem.FromVertex<V>
GraphSearchProblem.FromVertex.CostType<E>
GraphSearchProblem.FromVertex.CostType.HeuristicType<C extends Comparable<C>>
GraphSearchProblem.FromVertex.CostType.HeuristicType.Final

H

HashBasedHipsterDirectedGraph<V, E>	Implementation of a HipsterDirectedGraph using a Guava Hash Table.
HashBasedHipsterGraph<V, E>	Lightweight implementation of an in-memory, mutable graph backed to a HashMap where keys are vertices and edges are `GraphEdge`s
HashQueue<S>	Implementation of a java.util.Queue backed by a java.util.LinkedHashSet
HashTableHipsterDirectedGraph<V, E>	Implementation of a HipsterDirectedGraph using a Guava Hash Table.
HashTableHipsterGraph<V, E>	Implementation of a HipsterGraph using a Guava Hash Table.
HeuristicFunction<S, C>	Defines a function that takes a state and estimates the distance to the goal of the problem.
HeuristicNode<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>	Type of node which stores an estimated (heuristic) cost to the goal, extending the interface of a cost node `CostNode`.
HeuristicNodePriorityEvaluator<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>	Calculates the priority (double) of a `HeuristicNode` based translating on a cost extending java.lang.Number.
HillClimbing<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>	Implementation of the Hill Climbing algorithm.
HillClimbing.EHCIterator
Hipster	Util class to create algorithms easily.
HipsterDirectedGraph<V, E>	A simple representation of a directed graph with two methods for retrieving the outgoing edges and the incoming edges for a vertex.
HipsterGraph<V, E>	Basic definition of the read-only methods for a graph in terms of edges and vertices.
HipsterMutableGraph<V, E>	Interface that defines the basic mutable methods to manipulate graphs

I

IDAStar<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>	Implementation of the IDA* algorithm.
IDAStar.Iterator	IDA iterator.
Iterators
Iterators.AbstractIterator<E>

J

JUNGHipsterDirectedGraphAdapter<V, E>	An adapter class to adapt a JUNG graph to the Hipster Graph interface.
JUNGHipsterGraphAdapter<V, E>	An adapter to adapt a JUNG graph to a general HipsterGraph interface.

L

LazyActionStateTransitionFunction<A, S>	Implementation of a `TransitionFunction` generates an java.lang.Iterable of `Transition` which are instantiated in a lazy way, as the elements are iterated by the algorithms, and not in advance.
LazyNodeExpander<A, S, N extends Node<A, S, N>>	Implementation of a `NodeExpander` which generates an java.lang.Iterable of `Node` which are instantiated in a lazy way, as required by the algorithms, and not in advance.

M

Maze2D	This class defines a 2D ASCII Maze used to easily validate the search algorithms.
Maze2D.Symbol	Symbols allowed to create a maze
Mazes	Class containing a set of `Maze2D` to execute in the tests of the search iterators.
Mazes.TestMaze	ASCII Maze examples with the shortest path distance.
MazeSearch	This class executes the search iterators over maps of type `Maze2D`.
MazeSearch.Result	Inner class to define the results of the search process over `Maze2D`.
MazeShortestPathExample	Example using a bidimensional maze, solved using the A* algorithm.
MultiobjectiveLS<A, S, C extends Comparable<C>, N extends HeuristicNode<A, S, C, N>>	Implementation of the multi-objective label setting algorithm described by Martins and Santos.
MultiobjectiveLS.Iterator	MultiobjectiveLS iterator.

N

NegativeCycleException
Node<A, S, N extends Node<A, S, N>>	A node encapsulates the information generated by the search algorithms during their execution.
NodeExpander<A, S, N extends Node<A, S, N>>	Defines a function that takes a `Node` and expands it in order to generate all the possible successors.
NodeFactory<A, S, N>	Generator of nodes.
NPuzzle	General N-Puzzle problem.
NPuzzle.Puzzle	Puzzle class represents the state codification for this game.
NPuzzle.PuzzleMove	Actions that can be used in the N-Puzzle game.
NQueens	General N-Queens problem.

P

Pair<E>
Predicate<T>	Definition of predictcate to be used with search iterators implementing the class `Algorithm`.
PriorityEvaluator<N>	This interface is intended for the definition of evaluators to calculate the priority (double) of a concrete element.
PriorityFibonacciQueue<N>	Implementation of java.util.Queue based on the Fibonacci heap concept, described in http://en.wikipedia.org/wiki/Fibonacci_heap.
ProblemBuilder	Problem builder that is used to guide the user through the creation of a `SearchProblem` with the main components required to instantiate an algorithm.
ProblemBuilder.Wizard	Internal wizard assistant class.
ProblemBuilder.Wizard.ActionState<S>	Step to define the initial state of the problem.
ProblemBuilder.Wizard.ActionState.Uninformed<A>	Creates a uninformed problem (a problem without a cost/heuristic evaluator) to be used with uninformed algorithms like DFS, BFS.
ProblemBuilder.Wizard.ActionState.Uninformed.Informed<C extends Comparable<C>>	An informed search problem builder generates informed search problems with a generic cost
ProblemBuilder.Wizard.ActionState.Uninformed.Informed.Heuristic	Defines the heuristic function to be used.
ProblemBuilder.Wizard.ActionState.WithAction	Builder step to define a search problem with actions.
ProblemBuilder.Wizard.ActionState.WithAction.Action<A>	Builder step to select the transition function of a action-explicit search problem.
ProblemBuilder.Wizard.ActionState.WithoutAction	Builder step to define a search problem without actions.
Product	Implementation of `ScalarFunction` product for java.lang.Double elements.

R

RomanianProblem	Definition of the states, transitions, costs and heuristics for the Romania Problem as described in http://www.pearsonhighered.com/assets/hip/us/hip_us_pearsonhighered/samplechapter/0136042597.pdf.
RomanianProblem.City	Enum with all the cities of the problem.
RomanianProblemExample	Example of graph search using the Romania problem described here.

S

ScalarFunction<T>	A scalar function takes an object and modifies its magnitude by a numeric factor without changing its type.
ScalarOperation<E extends Comparable<E>>	A scalar operation is an implementation of `ScalarFunction` that also defines: identity element (A*i = A)
SearchComponents<A, S, C extends Comparable<C>>	This class should be used to instantiate an ADStar algorithm through the `Hipster.createADStar` method.
SearchProblem<A, S, N extends Node<A, S, N>>	Defines a search problems in terms of a initial node to start with and the node expander function that generates new successor nodes.
SimpleEightPuzzleExample	Example of using Hipster to solve the 8-puzzle search problem problem using the Dijkstra's algorithm.
SimpleTransition<S>	A SimpleTransition is just a transition without explicit actions `Transition<Void,S>`.
StateTransitionFunction<S>	Implementation of a `TransitionFunction` which generates an java.lang.Iterable of `Transition` which are instantiated in a lazy way, as the elements are iterated by the algorithms, and not in advance.

T

Transition<A, S>	Defines a transition between states.
TransitionFunction<A, S>	Defines a function that returns the possible transitions from a given state.

U

UndirectedEdge<V, E>
UndirectedGraphSearchExample	Example of graph search with manual creation of the graph structure.
UniqueEdge<V>	Dumb class that can be used to generate unique edges for a graph with a value.
UnorderedPair<E>
UnweightedNode<A, S>	Simple implementation of a search node which does not keep any information about costs.

W

WeightedNode<A, S, C extends Comparable<C>>	Basic implementation of a node which does not which keeps information about the cost.
WeightedNodeFactory<A, S, C extends Comparable<C>>	Implementation of `NodeFactory` for nodes of type `WeightedNode`.